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