Show More
@@ -1,407 +1,413 | |||
|
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 | 176 | can be visualized by graphical tools such as :hg:`log --graph`. In |
|
177 | 177 | Mercurial, the DAG is limited by the requirement for children to |
|
178 | 178 | have at most two parents. |
|
179 | 179 | |
|
180 | Deprecated | |
|
181 | Feature removed from documentation, but not scheduled for removal. | |
|
182 | ||
|
180 | 183 | Default branch |
|
181 | 184 | See 'Branch, default'. |
|
182 | 185 | |
|
183 | 186 | Descendant |
|
184 | 187 | Any changeset that can be reached by a chain of child changesets |
|
185 | 188 | from a given changeset. More precisely, the descendants of a |
|
186 | 189 | changeset can be defined by two properties: the child of a |
|
187 | 190 | changeset is a descendant, and the child of a descendant is a |
|
188 | 191 | descendant. See also: 'Ancestor'. |
|
189 | 192 | |
|
190 | 193 | Diff |
|
191 | 194 | (Noun) The difference between the contents and attributes of files |
|
192 | 195 | in two changesets or a changeset and the current working |
|
193 | 196 | directory. The difference is usually represented in a standard |
|
194 | 197 | form called a "diff" or "patch". The "git diff" format is used |
|
195 | 198 | when the changes include copies, renames, or changes to file |
|
196 | 199 | attributes, none of which can be represented/handled by classic |
|
197 | 200 | "diff" and "patch". |
|
198 | 201 | |
|
199 | 202 | Example: "Did you see my correction in the diff?" |
|
200 | 203 | |
|
201 | 204 | (Verb) Diffing two changesets is the action of creating a diff or |
|
202 | 205 | patch. |
|
203 | 206 | |
|
204 | 207 | Example: "If you diff with changeset X, you will see what I mean." |
|
205 | 208 | |
|
206 | 209 | Directory, working |
|
207 | 210 | The working directory represents the state of the files tracked by |
|
208 | 211 | Mercurial, that will be recorded in the next commit. The working |
|
209 | 212 | directory initially corresponds to the snapshot at an existing |
|
210 | 213 | changeset, known as the parent of the working directory. See |
|
211 | 214 | 'Parent, working directory'. The state may be modified by changes |
|
212 | 215 | to the files introduced manually or by a merge. The repository |
|
213 | 216 | metadata exists in the .hg directory inside the working directory. |
|
214 | 217 | |
|
215 | 218 | Draft |
|
216 | 219 | Changesets in the draft phase have not been shared with publishing |
|
217 | 220 | repositories and may thus be safely changed by history-modifying |
|
218 | 221 | extensions. See :hg:`help phases`. |
|
219 | 222 | |
|
223 | Experimental | |
|
224 | Feature that may change or be removed at a later date. | |
|
225 | ||
|
220 | 226 | Graph |
|
221 | 227 | See DAG and :hg:`log --graph`. |
|
222 | 228 | |
|
223 | 229 | Head |
|
224 | 230 | The term 'head' may be used to refer to both a branch head or a |
|
225 | 231 | repository head, depending on the context. See 'Head, branch' and |
|
226 | 232 | 'Head, repository' for specific definitions. |
|
227 | 233 | |
|
228 | 234 | Heads are where development generally takes place and are the |
|
229 | 235 | usual targets for update and merge operations. |
|
230 | 236 | |
|
231 | 237 | Head, branch |
|
232 | 238 | A changeset with no descendants on the same named branch. |
|
233 | 239 | |
|
234 | 240 | Head, closed branch |
|
235 | 241 | A changeset that marks a head as no longer interesting. The closed |
|
236 | 242 | head is no longer listed by :hg:`heads`. A branch is considered |
|
237 | 243 | closed when all its heads are closed and consequently is not |
|
238 | 244 | listed by :hg:`branches`. |
|
239 | 245 | |
|
240 | 246 | Closed heads can be re-opened by committing new changeset as the |
|
241 | 247 | child of the changeset that marks a head as closed. |
|
242 | 248 | |
|
243 | 249 | Head, repository |
|
244 | 250 | A topological head which has not been closed. |
|
245 | 251 | |
|
246 | 252 | Head, topological |
|
247 | 253 | A changeset with no children in the repository. |
|
248 | 254 | |
|
249 | 255 | History, immutable |
|
250 | 256 | Once committed, changesets cannot be altered. Extensions which |
|
251 | 257 | appear to change history actually create new changesets that |
|
252 | 258 | replace existing ones, and then destroy the old changesets. Doing |
|
253 | 259 | so in public repositories can result in old changesets being |
|
254 | 260 | reintroduced to the repository. |
|
255 | 261 | |
|
256 | 262 | History, rewriting |
|
257 | 263 | The changesets in a repository are immutable. However, extensions |
|
258 | 264 | to Mercurial can be used to alter the repository, usually in such |
|
259 | 265 | a way as to preserve changeset contents. |
|
260 | 266 | |
|
261 | 267 | Immutable history |
|
262 | 268 | See 'History, immutable'. |
|
263 | 269 | |
|
264 | 270 | Merge changeset |
|
265 | 271 | See 'Changeset, merge'. |
|
266 | 272 | |
|
267 | 273 | Manifest |
|
268 | 274 | Each changeset has a manifest, which is the list of files that are |
|
269 | 275 | tracked by the changeset. |
|
270 | 276 | |
|
271 | 277 | Merge |
|
272 | 278 | Used to bring together divergent branches of work. When you update |
|
273 | 279 | to a changeset and then merge another changeset, you bring the |
|
274 | 280 | history of the latter changeset into your working directory. Once |
|
275 | 281 | conflicts are resolved (and marked), this merge may be committed |
|
276 | 282 | as a merge changeset, bringing two branches together in the DAG. |
|
277 | 283 | |
|
278 | 284 | Named branch |
|
279 | 285 | See 'Branch, named'. |
|
280 | 286 | |
|
281 | 287 | Null changeset |
|
282 | 288 | The empty changeset. It is the parent state of newly-initialized |
|
283 | 289 | repositories and repositories with no checked out revision. It is |
|
284 | 290 | thus the parent of root changesets and the effective ancestor when |
|
285 | 291 | merging unrelated changesets. Can be specified by the alias 'null' |
|
286 | 292 | or by the changeset ID '000000000000'. |
|
287 | 293 | |
|
288 | 294 | Parent |
|
289 | 295 | See 'Changeset, parent'. |
|
290 | 296 | |
|
291 | 297 | Parent changeset |
|
292 | 298 | See 'Changeset, parent'. |
|
293 | 299 | |
|
294 | 300 | Parent, working directory |
|
295 | 301 | The working directory parent reflects a virtual revision which is |
|
296 | 302 | the child of the changeset (or two changesets with an uncommitted |
|
297 | 303 | merge) shown by :hg:`parents`. This is changed with |
|
298 | 304 | :hg:`update`. Other commands to see the working directory parent |
|
299 | 305 | are :hg:`summary` and :hg:`id`. Can be specified by the alias ".". |
|
300 | 306 | |
|
301 | 307 | Patch |
|
302 | 308 | (Noun) The product of a diff operation. |
|
303 | 309 | |
|
304 | 310 | Example: "I've sent you my patch." |
|
305 | 311 | |
|
306 | 312 | (Verb) The process of using a patch file to transform one |
|
307 | 313 | changeset into another. |
|
308 | 314 | |
|
309 | 315 | Example: "You will need to patch that revision." |
|
310 | 316 | |
|
311 | 317 | Phase |
|
312 | 318 | A per-changeset state tracking how the changeset has been or |
|
313 | 319 | should be shared. See :hg:`help phases`. |
|
314 | 320 | |
|
315 | 321 | Public |
|
316 | 322 | Changesets in the public phase have been shared with publishing |
|
317 | 323 | repositories and are therefore considered immutable. See :hg:`help |
|
318 | 324 | phases`. |
|
319 | 325 | |
|
320 | 326 | Pull |
|
321 | 327 | An operation in which changesets in a remote repository which are |
|
322 | 328 | not in the local repository are brought into the local |
|
323 | 329 | repository. Note that this operation without special arguments |
|
324 | 330 | only updates the repository, it does not update the files in the |
|
325 | 331 | working directory. See :hg:`help pull`. |
|
326 | 332 | |
|
327 | 333 | Push |
|
328 | 334 | An operation in which changesets in a local repository which are |
|
329 | 335 | not in a remote repository are sent to the remote repository. Note |
|
330 | 336 | that this operation only adds changesets which have been committed |
|
331 | 337 | locally to the remote repository. Uncommitted changes are not |
|
332 | 338 | sent. See :hg:`help push`. |
|
333 | 339 | |
|
334 | 340 | Repository |
|
335 | 341 | The metadata describing all recorded states of a collection of |
|
336 | 342 | files. Each recorded state is represented by a changeset. A |
|
337 | 343 | repository is usually (but not always) found in the ``.hg`` |
|
338 | 344 | subdirectory of a working directory. Any recorded state can be |
|
339 | 345 | recreated by "updating" a working directory to a specific |
|
340 | 346 | changeset. |
|
341 | 347 | |
|
342 | 348 | Repository head |
|
343 | 349 | See 'Head, repository'. |
|
344 | 350 | |
|
345 | 351 | Revision |
|
346 | 352 | A state of the repository at some point in time. Earlier revisions |
|
347 | 353 | can be updated to by using :hg:`update`. See also 'Revision |
|
348 | 354 | number'; See also 'Changeset'. |
|
349 | 355 | |
|
350 | 356 | Revision number |
|
351 | 357 | This integer uniquely identifies a changeset in a specific |
|
352 | 358 | repository. It represents the order in which changesets were added |
|
353 | 359 | to a repository, starting with revision number 0. Note that the |
|
354 | 360 | revision number may be different in each clone of a repository. To |
|
355 | 361 | identify changesets uniquely between different clones, see |
|
356 | 362 | 'Changeset id'. |
|
357 | 363 | |
|
358 | 364 | Revlog |
|
359 | 365 | History storage mechanism used by Mercurial. It is a form of delta |
|
360 | 366 | encoding, with occasional full revision of data followed by delta |
|
361 | 367 | of each successive revision. It includes data and an index |
|
362 | 368 | pointing to the data. |
|
363 | 369 | |
|
364 | 370 | Rewriting history |
|
365 | 371 | See 'History, rewriting'. |
|
366 | 372 | |
|
367 | 373 | Root |
|
368 | 374 | A changeset that has only the null changeset as its parent. Most |
|
369 | 375 | repositories have only a single root changeset. |
|
370 | 376 | |
|
371 | 377 | Secret |
|
372 | 378 | Changesets in the secret phase may not be shared via push, pull, |
|
373 | 379 | or clone. See :hg:`help phases`. |
|
374 | 380 | |
|
375 | 381 | Tag |
|
376 | 382 | An alternative name given to a changeset. Tags can be used in all |
|
377 | 383 | places where Mercurial expects a changeset ID, e.g., with |
|
378 | 384 | :hg:`update`. The creation of a tag is stored in the history and |
|
379 | 385 | will thus automatically be shared with other using push and pull. |
|
380 | 386 | |
|
381 | 387 | Tip |
|
382 | 388 | The changeset with the highest revision number. It is the changeset |
|
383 | 389 | most recently added in a repository. |
|
384 | 390 | |
|
385 | 391 | Tip, branch |
|
386 | 392 | The head of a given branch with the highest revision number. When |
|
387 | 393 | a branch name is used as a revision identifier, it refers to the |
|
388 | 394 | branch tip. See also 'Branch, head'. Note that because revision |
|
389 | 395 | numbers may be different in different repository clones, the |
|
390 | 396 | branch tip may be different in different cloned repositories. |
|
391 | 397 | |
|
392 | 398 | Update |
|
393 | 399 | (Noun) Another synonym of changeset. |
|
394 | 400 | |
|
395 | 401 | Example: "I've pushed an update". |
|
396 | 402 | |
|
397 | 403 | (Verb) This term is usually used to describe updating the state of |
|
398 | 404 | the working directory to that of a specific changeset. See |
|
399 | 405 | :hg:`help update`. |
|
400 | 406 | |
|
401 | 407 | Example: "You should update". |
|
402 | 408 | |
|
403 | 409 | Working directory |
|
404 | 410 | See 'Directory, working'. |
|
405 | 411 | |
|
406 | 412 | Working directory parent |
|
407 | 413 | See 'Parent, working directory'. |
General Comments 0
You need to be logged in to leave comments.
Login now