[IFT] Split Java Declaration lesson for general Declaration and Usages lesson and...
[idea/contrib.git] / ide-features-trainer / res / messages / LessonsBundle.properties
1 ### Ths file contains strings from lessons.
2
3 ###############################################################################
4 ## Common lessons
5 ###############################################################################
6
7 ## Editor basics module
8
9 goto.action.lesson.name=Search for actions
10 goto.action.mac.workaround=\nIf <strong>Terminal</strong> search opens instead of {0}, refer to <a href="{1}">this article</a>.
11 goto.action.use.find.action=One of the most useful shortcuts is {0}. It lets you search through all available \
12   actions without having to know their individual shortcuts. Try it now with {1}.
13 goto.action.invoke.about.action=Let''s say you want to learn about {0}, type {1} and press {2}.
14 goto.action.to.return.to.the.editor=Press {0} to return to the editor.
15 goto.action.invoke.again= You can also use {0} to change the settings, invoke it again now.
16 goto.action.show.line.numbers.request=Type {0} to see {1} selector.
17 goto.action.first.lines.toggle=Switch the line numbers {0, choice, 0#off|1#on}.
18 goto.action.second.lines.toggle=Now switch the line numbers back {0, choice, 0#on|1#off}.
19 goto.action.propose.to.go.next=Awesome! Click the button below to start the next lesson, or use {0}.
20
21 collapse.lesson.name=Collapse
22 collapse.try.collapse=Sometimes you need to collapse a piece of code for better readability. Try to collapse a code fragment with {0}.
23 collapse.hit.expand=To expand a code region, press {0}.
24 collapse.all.collapse=If you want to collapse all regions in the file, press{0}.
25 collapse.all.expand=Similarly, press {0} to expand all available regions.
26
27 duplicate.and.delete.lines.lesson.name=Duplicate and delete lines
28 duplicate.and.delete.lines.duplicate.line=Duplicate any line with {0}.
29 duplicate.and.delete.lines.duplicate.several.lines=You can apply the same action to multiple lines too. \
30   Simply select two or more lines and duplicate them with {0}.
31 duplicate.and.delete.lines.delete.line=To delete the current line you can use action {0}.
32
33 move.lesson.name=Move
34 move.pull.down=Rearranging lines usually involves two actions: cut and paste. \
35   With {0}, you can do it with just one. Press {1} to pull down the current line.
36 move.pull.up=Similarly, to pull a line up, press {0}.
37 move.whole.method.up=Now try to move the whole method up with {0}.
38 move.whole.method.down=Now move it down with {0}.
39
40 multiple.selections.lesson.name=Multiple selections
41 multiple.selections.select.symbol=Press {0} to select the symbol at the caret.
42 multiple.selections.select.next.symbol=Press {0} again to select the next occurrence of this symbol.
43 multiple.selections.deselect.symbol=Press {0} to deselect the last occurrence.
44 multiple.selections.select.all=Press {0} to select all occurrences in the file.
45 multiple.selections.replace=Type {0} to replace all occurrences of {1} with {0}.
46
47 selection.lesson.name=Expand and shrink the code selection
48 selection.select.word=Place the caret before any word. Press {0} to move the caret to the next word and select everything in between.
49 selection.extend.selection=Press {0} to extend the selection to the next code block.
50 selection.extend.until.whole.file=Try to increase your selection with {0} until your whole file is selected.
51 selection.shrink.selection={0} shrinks the selection. Try pressing it.
52
53 comment.line.lesson.name=Comment line
54 comment.line.comment.any.line=Comment out any line with {0}.
55 comment.line.uncomment.that.line=Uncomment the commented line with the same shortcut, {0}.
56 comment.line.comment.several.lines=Select several lines and then comment them with {0}.
57
58 surround.and.unwrap.lesson.name=Surround and unwrap
59 surround.and.unwrap.invoke.surround=Press {0} to surround the selected code fragment with some template code.
60 surround.and.unwrap.choose.surround.item=Choose {0} item.
61 surround.and.unwrap.invoke.unwrap=Let''s return to the initial file with the unwrapping action by {0}.
62 surround.and.unwrap.choose.unwrap.item=Choose {0} item.
63
64 ## Completion module
65
66 basic.completion.lesson.name=Basic completion
67 basic.completion.start.typing=By default, {0} proposes completion for your code instantly. \
68   Start typing {1} right where the caret is, and you will see the Lookup Menu with matching suggestions.
69 basic.completion.continue.typing=Continue typing {0} unless it becomes the first item.
70 basic.completion.just.press.to.complete=Now just press {0} to complete this statement.
71 basic.completion.activate.explicitly=To activate Basic Completion explicitly, press {0}.
72 basic.completion.finish.explicit.completion=Select {0} and press {1}.
73
74 completion.with.tab.lesson.name=Completion with tab
75 completion.with.tab.begin.completion=Press {0} to show completion options.
76 completion.with.tab.finish.with.tab=Choose {0}, for example, and press {1}. \
77   This replaces the word at the caret rather than simply inserts it.
78
79 postfix.completion.lesson.name=Postfix completion
80 postfix.completion.type.template={0} can offer postfix shortcuts. Type {1}.
81
82 rename.lesson.name=Rename
83
84 refactoring.menu.lesson.name=Refactoring menu
85 refactoring.menu.show.refactoring.list={0} supports a variety of refactorings. Many of them have own shortcuts. \
86   But for rare refactorings you can press {1} and preview a partial list of them.
87 refactoring.menu.introduce.parameter=Suppose we want to replace this expression with a parameter. So we need to choose {0}. \
88   Now simply type <strong>pa</strong> (introduce <strong>pa</strong>rameter) or \
89   <strong>ip</strong> (<strong>i</strong>ntroduce <strong>p</strong>arameter) to reduce the proposed list.
90 refactoring.menu.start.refactoring=Press {0} to start the {1} refactoring. \
91   <strong>Note</strong> that you can learn refactoring shortcuts from the Refactoring menu.
92 refactoring.menu.finish.refactoring=To complete refactoring, you need to choose some name or leave it as default and press {0}.
93
94 ## Navigation module
95
96 declaration.and.usages.lesson.name=Declaration and usages
97 declaration.and.usages.jump.to.declaration=Press {0} to jump to the declaration of {1, choice, 0#a method|1#an attribute accessor}.
98 declaration.and.usages.show.usages=Now the caret is at the {0, choice, 0#method|1#attribute accessor} declaration. \
99   Use the same shortcut {1} to see all of its usages, then select one of them.
100 declaration.and.usages.find.usages=Press {0} to see a more detailed view of usages. You can invoke {0} on either a declaration or usage.
101 declaration.and.usages.pin.motivation=From the {0} view you can navigate to both usages and declarations. \
102   The next search will override these results in the {0} view. To prevent it, pin the results:
103 declaration.and.usages.right.click.tab=Right click the tab title, {0}.
104 declaration.and.usages.select.pin.item=Select {0}.
105 declaration.and.usages.hide.view=When you have finished browsing usages, press {0} to hide the view.
106 declaration.and.usages.open.find.view=Press {0} to open the {1} view again.
107
108 file.structure.lesson.name=File structure
109 file.structure.open.popup=A large source file can be difficult to read and navigate, sometimes you only need to preview it. \
110   Press {0} to open the file structure.
111 file.structure.request.prefixes=Suppose you want to find some method with {0} and {1} words in its name. \
112   Type {2} (prefixes of the required words) to filter file structure.
113 file.structure.navigate=Only one item remains. Now press {0} to jump to the selected item.
114 file.structure.toolwindow={0} can also show you the file structure as a tool window. Open it with {1}.
115
116 extract.method.lesson.name=Extract method
117 extract.method.invoke.action=Press {0} to extract the selected code block into a method.
118 extract.method.start.refactoring=Click {0} to start refactoring.
119 extract.method.confirm.several.replaces=Cocktail Sort has two swap places. The first fragment has just been extracted. \
120   Click {0} to extract both of them.
121 extract.method.second.fragment=Now you can confirm or reject the replacement of the second fragment.
122
123 extract.variable.lesson.name=Extract variable
124 extract.variable.start.refactoring=Press {0} to extract a local variable from the selected expression {1}.
125 extract.variable.replace.all=This code block contains 3 occurrences of the selected expression. \
126   Choose the second item on the list to replace all of them.
127 extract.variable.choose.name=Choose a name for the new variable or leave it as it is. Press {0} to complete the refactoring.
128
129 ## Run/Debug module
130
131 run.configuration.lesson.name=Run configuration
132 run.configuration.hide.toolwindow={0} automatically opened the {1} tool window. \
133   Tip: at the top of the {1} tool window you can see the full run command. Now let''s hide the tool window with {2}.
134 run.configuration.temporary.to.permanent=For each new run {0} create temporary run configuration. \
135   Temporary configurations are automatically deleted if the default limit of five is reached. \
136   Let''s convert the temporary configuration into a permanent one. Open the drop-down menu with run configurations.
137 run.configuration.select.save.configuration=Select {0}.
138 run.configuration.edit.configuration=Suppose you want to change a configuration or create another one manually. \
139   Then you need to open the drop-down menu again and click {0}. Alternatively you can use {1} action.
140 run.configuration.settings.description=This is a place for managing run/debug configurations. \
141   You can set here program parameters, JVM arguments, environment variables, and so on.
142 run.configuration.tip.about.save.configuration.into.file=Tip:  Sometimes you may want to save a configuration to its own file. \
143   Such configurations will be easy to share between colleagues (usually by the version control system). \
144   Now close the settings dialog to finish this lesson.
145
146 debug.workflow.lesson.name=Debug workflow
147 debug.workflow.incorrect.breakpoints=Breakpoints are set incorrectly for this lesson.
148 debug.workflow.run.program=Before debugging let''s run the program and see what is going wrong {0}.
149 debug.workflow.toggle.breakpoint=So, there is a problem. Let''s start investigation with placing breakpoint. \
150   To toggle a breakpoint you should click left editor gutter or just press {0}.
151 debug.workflow.start.debug=To start debug selected run configuration, click {0} or press {1}.
152 debug.workflow.return.to.editor=Many trace actions will focus debug toolwindow. Let''s return to the editor with {0}.
153 debug.workflow.use.watches={0} has several ways to show variable values. For this step, we selected the call. Let''s add it to {1}. \
154   You can copy the expression into the clipboard, click {2} button on the debug panel and paste the copied text. \
155   Alternatively, you can just use action {3} {4}.
156 debug.workflow.consider.to.add.a.shortcut=(consider to assign a shortcut for it later)
157 debug.workflow.step.into=Lets step into. You can use action {0} or the button {1} at the debug panel.
158 debug.workflow.choose.method.to.step.in=In most cases you will want to skip argument calculating so Smart Step Into feature suggest by \
159   default the wrapping method. However, here we need to choose the second one: {0}. \
160   You can choose it by keyboard {1} and press {2}, or you can click the call.
161 debug.workflow.quick.evaluate=Let''s see what we are going to pass to {0}. Invoke Quick Evaluate Expression {1} for the selected argument.
162 debug.workflow.fix.error=Oh, we made a mistake in the array index! Let''s fix it right now. Close popup ({0}) and change 0 to 1.
163 debug.workflow.step.over=Let''s check that the call of {0} will not throw an exception now. Use Step Over action {1} or click the button {2}.
164 debug.workflow.mute.breakpoints=Ups, the same breakpoint again. Now we don''t need to stop at this breakpoint. \
165   So, let''s mute breakpoints by clicking the button {0} or with the  action {1}.
166 debug.workflow.run.to.cursor=Let''s check the result of {0}. We''ve moved the editor cursor to the {1} statement. \
167   Let''s use {2} or click {3}. Note that {4} works even if breakpoints are muted.
168 debug.workflow.evaluate.expression=It seems the {0} is not an average value we want to find. We forgot to divide by length. \
169   Seems we need to return {1}. Let''s check the guess. Press {2} or click button {3}.
170 debug.workflow.type.result=Type {0} into the {1} field, completion works.
171 debug.workflow.evaluate.it=Press {0} or click {1}.
172 debug.workflow.stop.debug=It will be a correct answer! Lets close the dialog and stop debugging by {0} or button {1}.
173 debug.workflow.resume=Seems there are no exceptions by now. Let''s continue execution with {0} or click the button {1}.
174
175 ###############################################################################
176 ## Java lessons
177 ###############################################################################
178
179 java.basic.completion.choose.first=You can choose the first item from the Lookup menu by pressing {0}.
180 java.basic.completion.activate=To activate Basic Completion, press {0} and you will see the lookup menu again.
181 java.basic.completion.choose.item=Select {0} inside the lookup menu and press {1}.
182 java.basic.completion.complete=Press {0} to complete this statement.
183 java.basic.completion.deeper.level=Sometimes you need to see suggestions for static constants or methods. \
184   Press {0} twice to access extended Code Completion.
185
186 java.run.configuration.lets.run=Any code marked with {0} can be run. Let''s run our simple example with {1}. \
187   Alternatively, you can click {0} and select the {2} item.
188
189 java.postfix.completion.apply=Postfix Completion helps reduce backward caret jumps as you write code. \
190   It lets you transform an already typed expression into another one based on the postfix you add, the type of expression, and its context. \
191   Type {0} after the parenthesis to see the list of postfix completion suggestions. \
192   Select {1} from the list, or type it in the editor, and then press {2} to complete the statement.
193
194 java.smart.type.completion.lesson.name=Smart type completion
195 java.smart.type.completion.apply=Smart Type Completion filters the list of suggestion to include only those types that are applicable \
196   within the current context. Press {0} to see the list of matching suggestions. Choose the first one by pressing {1}.
197 java.smart.type.completion.return=Smart Type Completion can also suggest code for a return statement. \
198   Press {0} twice to see the Lookup menu for a return. Choose the first one by pressing {1}
199
200 java.statement.completion.lesson.name=Statement completion
201 java.statement.completion.complete.for=Press {0} to complete the {1} statement.
202 java.statement.completion.complete.if=Type {0} and press {1} to generate the statement.
203 java.statement.completion.complete.condition=Add a condition inside parentheses {0} and press {1} to jump inside the {2} statement.
204 java.statement.completion.complete.finish.body=Type on one line: {0} and then press {1} to complete the entered statement and apply formatting.
205
206 java.rename.press.rename=Press {0} to rename field {1}.
207 java.rename.type.new.name=Type the new name for this field (e.g., {0}) and press {1}.
208 java.rename.confirm.accessors.rename={0} is detecting corresponding getters/setters and proposes to rename them accordingly.\
209   Now just press {1} or click {2}
210
211 java.refactoring.menu.inline.variable=Now let''s inline variable {0} into the only use. You can press {1} and filter by <strong>iv</strong> (<strong>i</strong>nline <strong>v</strong>ariable). Or just press {2}.
212 java.refactoring.menu.introduce.constant=In the end, let''s extract extension from file name. Again, you can press {0} and filter by <strong>ic</strong> (<strong>i</strong>ntroduce <strong>c</strong>onstant). Or just press {1}.
213 java.refactoring.menu.confirm.constant=In this dialog you can choose the name, the parent and visibility for the new constant. You can leave proposed defaults and press {0} or click {1}.
214
215 java.inheritance.hierarchy.lesson.name=Inheritance hierarchy
216 java.inheritance.hierarchy.goto.implementation=Press {0} to look for implementations of {1}.
217 java.inheritance.hierarchy.choose.any.implementation=Choose any implementation and press {0} (or click it by mouse).
218 java.inheritance.hierarchy.navigate.to.base=You can navigate to a super method from derived. Press {0} or click icon {1} in the editor gutter.
219 java.inheritance.hierarchy.invoke.implementations.again=The declaration of the base method has its own gutter icon {0}. \
220   Click it or press {1} again.
221 java.inheritance.hierarchy.open.in.find.tool.window=For big hierarchies you may want to look for implementations in the {0} tool window. \
222   Click at {1}.
223 java.inheritance.hierarchy.hide.find.tool.window=Press {0} to hide the {1} tool window.
224 java.inheritance.hierarchy.open.method.hierarchy=You may want to explore the whole hierarchy for this method. Press {0}.
225 java.inheritance.hierarchy.hide.method.hierarchy=Let''s hide {0} also. Press {1} again.
226 java.inheritance.hierarchy.open.class.hierarchy=To overview the class hierarchy press {0}.
227 java.inheritance.hierarchy.last.note=<strong>Note:</strong> Actions {0} and {1} can be applied to classes also. \
228   Actions {2} and {3} may be used rarely but you always can find them with {4} by the {5} filter.
229
230 java.debug.workflow.rebuild=For big programs rerun can take much time. When you find some mistake in pure method you can just rebuild \
231   the project and apply <strong>Hot Swap</strong> JVM feature. Let''s build project: {0} or {1}.
232 java.debug.workflow.confirm.hot.swap=Confirm <strong>Hot Swap</strong> replacement.
233 java.debug.workflow.drop.frame=We patched our method, but right now we are still executing old obsolete {0} and it will throw the \
234   exception again. Let''s drop the frame and return to the state before {1} call. Click {2} at the debug panel or press {3}.
235
236 ###############################################################################
237 ## Python lessons
238 ###############################################################################
239
240 python.f.string.completion.lesson.name=F-string completion
241 python.f.string.completion.type.prefix={0} supports automatic f-string conversion. Just start to type {1}.
242 python.f.string.completion.invoke.manually=You can invoke completion manually with {0}.
243 python.f.string.completion.complete.it=Complete the statement with {0}. Just press {1} to apply the first item.
244 python.f.string.completion.result.message=You may see that a simple Python string was replaced by f-string after the completion.
245
246 python.postfix.completion.select.item=Select {0} item from completion list.
247
248 python.smart.completion.lesson.name=Smart completion
249 python.smart.completion.try.basic.completion=Try to use Basic Completion by pressing {0}.
250 python.smart.completion.use.smart.completion=Unfortunately {0} has no direct information about {1} type. \
251   But sometimes it can guess completion by the context! Use {2} to invoke Smart Completion.
252 python.smart.completion.finish.completion=Now just choose {0} item to finish this lesson.
253
254 python.tab.completion.lesson.name=Tab completion
255 python.tab.completion.start.completion=Suppose you want to replace {0} with {1}. Invoke completion by pressing {2}.
256 python.tab.completion.select.item=Select item {0} by keyboard arrows or just start typing it.
257 python.tab.completion.use.tab.completion=If you press {0} you will insert {1} before {2}. Instead press {3} to replace {2} with {1}.
258
259 python.search.everywhere.lesson.name=Search everywhere
260 python.search.everywhere.invoke.search.everywhere=To open {0} you need to press {1} two times in a row.
261 python.search.everywhere.type.prefixes=Suppose you are looking for a class with {0} and {1} words in the name. \
262   Type {2} (prefixes of required words) to the search field.
263 python.search.everywhere.preview=We found {0}. Now you can preview the found item. Just select it by keyboard arrows and press {1}.
264 python.search.everywhere.navigate.to.class=Press {0} to navigate to {1}.
265 python.search.everywhere.goto.class=Use {0} to find class faster or in special places.
266 python.search.everywhere.type.node.visitor=Suppose you need some library class responsible for visiting nodes. Type {0}.
267 python.search.everywhere.use.all.places=Now you see a class inside this demo project. \
268   Let''s switch {0} filter to {1} and you will see available libraries.
269 python.search.everywhere.quick.documentation=Press {0} to preview available documentation.
270 python.search.everywhere.finish=<strong>Done!</strong> In the same way you can use {0} to look for a method or global variable and use {1} \
271   to look for a file.
272
273 python.in.place.refactoring.lesson.name=In-place refactoring
274 python.in.place.refactoring.start.type.new.name=Let''s consider an alternative approach to performing refactorings. \
275   Suppose we want to rename local variable {0} to {1}. Just start typing the new name.
276 python.in.place.refactoring.invoke.intentions={0} is guessing that you are going to rename the variable. \
277   You can notice it by the icon {1} in the left editor gutter. Invoke intentions by {2} when you finish typing the new name.
278 python.in.place.refactoring.finish.rename=Press {0} to finish rename.
279 python.in.place.refactoring.add.parameter=Let''s add an argument to this method. We place the editor caret just after the first parameter. \
280   Now type comma and parameter''s name: {0}.
281 python.in.place.refactoring.invoke.intention.for.parameter={0} is guessing that you are going to change the method signature. \
282   You can notice it by the same icon {1} at the left editor gutter. Invoke intentions by {2} when you finish typing the new parameter.
283 python.in.place.refactoring.update.callers=Press {0} to update the callers.
284 python.in.place.refactoring.signature.preview={0} is showing you the short signature preview. Press {1} to continue.
285 python.in.place.refactoring.set.default.value=Now you need to type the value which will be inserted as an argument into each call. \
286   You can choose {0} for this sample. Then press {1} to continue.
287 python.in.place.refactoring.remark.about.application.scope=Note: In-place refactoring may be applied only in the \
288   definition point whiles direct invocation of rename or change-signature refactorings may be called from both definition and usage.
289
290 python.quick.fix.refactoring.lesson.name=Quick fix refactoring
291 python.quick.fix.refactoring.type.new.argument=Several refactorings can be performed as quick fixes. \
292   Suppose we want to add a parameter to the method {0} and pass the variable {1} to it. Let''s type {2} after the first argument.
293 python.quick.fix.refactoring.wait.completion.showed=Wait a little bit for the completion list...
294 python.quick.fix.refactoring.close.completion.list=For now, we don''t want to apply any completion. Close the list ({0}).
295 python.quick.fix.refactoring.invoke.intentions=As you may notice, {0} is showing you a warning here. Let''s invoke intentions by {1}.
296 python.quick.fix.refactoring.choose.change.signature=Choose {0} quick fix.
297 python.quick.fix.refactoring.select.new.parameter=Let''s set the default value for the new parameter. Click the new parameter line. \
298   Alternatively, you can set focus to the parameter without a mouse by {0} and then {1}.
299 python.quick.fix.refactoring.set.default.value=You may navigate through the fields (and the checkbox) by using {0}. \
300   With the checkbox, you can let {1} inline the default value to the other callers or set it as the default value for the new parameter. \
301   The Signature Preview will help you understand the difference. Now set the default value as 0.
302 python.quick.fix.refactoring.finish.refactoring=Press {0} (or click {1}) to finish the refactoring.
303
304 python.rename.press.rename=Press {0} to rename field {1} (e.g., to {2}).
305 python.rename.expand.dynamic.references=In simple cases {0} will just rename without confirmation. \
306   But in this sample, {0} detects two calls of {1} method for objects with unknown types. Expand {2} item.
307 python.rename.exclude.item=It seems {0} should be excluded from rename. Select it and press {1}.
308 python.rename.finish.refactoring=Now just finish the rename with the {0} button.
309
310 python.run.configuration.lets.run=Let''s run our simple example with {0}.
311
312 python.debug.workflow.rerun=Let''s rerun our program. Just click again at {0} or use {1}.
313
314 ###############################################################################
315 ## Ruby lessons
316 ###############################################################################
317
318 ruby.hippie.completion.lesson.name=Hippie Completion
319 ruby.hippie.completion.invoke.hippie.completion=Sometimes you need to complete a word by textual similarity. \
320   Press {0} to invoke hippie completion.
321 ruby.hippie.completion.repeat.one.time=You can repeat {0} until the desired word is found. Try it once more now.
322 ruby.hippie.completion.return.previous=You can return to the previous variant with {0}. Use it now.
323
324 ruby.postfix.completion.apply=Now just press {0} to choose the first postfix template.
325 ruby.postfix.completion.choose.target=Now choose the second item, {0}.
326
327 ruby.class.search.lesson.name=Class Search
328 ruby.class.search.invoke.goto.class=Try to find a class with {0}.
329 ruby.class.search.type.word=Type {0} to see classes that contain the word {1}.
330 ruby.class.search.type.second.prefix=You can search for a class by part of its name. \
331   Type {0} (the search string will be {1}) to see classes that contain the words {2} and {3}.
332 ruby.class.search.preview=To check the selected class before navigating to it, you can use {0} to see its quick definition.
333 ruby.class.search.navigate.to.target=Suppose you are looking for {0}. Choose it and then press {1} to navigate.
334
335 ruby.refactoring.menu.invoke.refactoring.list={0} supports a variety of refactorings. Press {1} to see a partial list of them.
336 ruby.refactoring.menu.use.push.method.down=Some refactorings are seldom used and have no shortcuts, but you can find them here. \
337   Choose {0} now and complete the refactoring on {1}.
338
339 ruby.rename.start.refactoring=Press {0} to rename the attribute accessor {1} (for example, to {2}).
340 ruby.rename.confirm=In order to be confident about the refactoring, {0} lets you preview it before confirming. \
341   Click {1} to complete the refactoring.
342
343 ###############################################################################
344 ## JS lessons
345 ###############################################################################
346
347 js.editor.module.title=Editor Basics
348
349 js.editor.completion.title=The Nuts and Bolts of Code Completion
350 js.editor.completion.choose.lookup={0} is full of features that help you write better code and increase your productivity. Let\u2019s start with code completion. It enables you to code faster by completing keywords and symbols from language APIs and project dependencies. Type {1} and hit {2} to autocomplete {3}.
351 js.editor.completion.choose.method=So, code completion shows context-aware suggestions as you type. To add one of these suggestions, you can use {0} like we just did, or press {1} to replace an existing item. Now add a {2} after {3}, then type {4} and autocomplete the {5} method with {0}.
352 js.editor.completion.parameter.info=The tooltip ({0}) we\u2019ve got after placing the caret inside {1} lets you quickly look up the names of parameters in methods and functions. In some situations, you may want to review more detailed documentation. Let\u2019s do it now by pressing {2}.
353 js.editor.completion.add.parameter=This is how you can look up JavaScript documentation right in WebStorm. Now add {0} inside {1} to continue.
354 js.editor.completion.console.log.argument=Finally, let\u2019s complete the {0} statement. Place the caret inside {1} on the line 8 and add {2} using code completion.
355 js.editor.completion.next=That\u2019s it for this lesson. To start the next one, click the button below or use {0}.
356
357 js.editor.code.editing.tips.and.tricks.title=Code Editing Tips and Tricks
358 js.editor.code.editing.reformat.start=Let''s go over some tips and tricks that can help you edit code a lot faster. For starters, there''s no need to manually fix code formatting with {0}. Reformat the code with {1}.
359 js.editor.code.editing.select.word=That\u2019s it! Now let\u2019s see how to quickly select pieces of code in a file. Press {0} a few times to fully select the second tr element (lines 14-18).
360 js.editor.code.editing.comment.delete.unselect.move.up=Now that you''ve selected the code, you can (un)comment it out ({0}), delete it ({1}), or shrink the selection ({2}).\nAnother thing you can do is move this code up or down the file. Let\u2019s move it up with {3}
361 js.editor.code.editing.multi.caret=Next up is multi-caret editing. Use it to save a bunch of time as you modify code in several spots at once. Place the caret inside the first {0} tag (line 10). Then select all {1} tags inside the same tr element (lines 10-12): press {2} six times until all the necessary tags are selected. \nLet''s replace {3} with {4} and hit {5} to exit the multi-caret mode.
362 js.editor.code.editing.duplicate.delete.comment=Finally, let\u2019s quickly try the most popular line actions, such as duplicate line ({0}), delete line ({1}), or comment it out ({2}). Use {0} to duplicate the selected line now. Then hit {1} and {2} to try the other line actions.
363 js.editor.code.editing.next=That''s it for this lesson. Click the button below to start the next one or use  {0}.
364
365 js.editor.code.inspection.title=The Power of Code Inspections
366 js.editor.code.inspection.intro=As you work in the editor, {0} constantly analyzes your code, detects various problems in it, and suggests how it can be improved. The opened file has two highlighted problems on lines 4 and 5. Let\u2019s check what they are by pressing {1}.
367 js.editor.code.inspection.show.intentions=You can also use {0} to jump from one error to another. Or, you can explore the found problems by hovering over them.\nIn this file, the IDE has located an unresolved variable \u2013 one that wasn''t defined anywhere in the code. It suggests creating a new one, {1}, as one of the possible fixes, but we need to add a parameter book instead. Place the caret on {2} and hit {3} to see the full list of fixes.
368 js.editor.code.inspection.run.intention=Let\u2019s select {0} and press {1}.
369 js.editor.code.inspection.checkmark=If you now look at the top right-hand corner of the editor, you\u2019ll see a green checkmark ({0}) confirming the file has no more problems. However, there\u2019s still a minor detail that can be optimized to make the code shorter. Place the caret on {1} (line 3) and press {2}.
370 js.editor.code.inspection.make.shorter=Now let\u2019s make our function expression shorter. Select the {0} quick-fix and hit {1}.
371 js.editor.code.inspection.next=That\u2019s it for this lesson. Click the button below to start the next one or use  {0}.
372
373 js.editor.navigation.title=Secrets of Efficient Navigation
374 js.editor.navigation.recent.files=Let\u2019s start with navigating around a project. Press {0} to call up the {1} popup.
375 js.editor.navigation.choose.structure=With this popup, you can quickly jump between recent files and IDE tool windows. One of those tool windows can assist you with navigating around a smaller piece of a project, a single file. Click the {0} tab to learn more about it.
376 js.editor.navigation.activate.structure=So, the {0} tool window can help you examine a file faster. It provides an overview of its structure and lets you jump to a specific item simply by typing its name. Start typing {1} anywhere in the tool window area, hit {2}, and then hit {3} to close the panel and jump to the code. 
377 js.editor.navigation.find.usages=As a result of our actions, the caret has moved to {0} (line 9). Let\u2019s leave it there and press {1} to open another tool window that can help you quickly find usages of any item. 
378 js.editor.navigation.hide.tool.window=Great! Now you can see the usages of giveTreat across the whole project and the libraries. Let\u2019s close the tool window with {0}.
379 js.editor.navigation.search.everywhere=Now press {0} twice to meet another feature that can help you search faster.
380 js.editor.navigation.search.everywhere.tabs=This is the {0} popup. It lets you instantly find any action, file, class or symbol, and shows all the matches in one place. If you want to run a more specific search, you can hit {1} to switch from {2} to any other tab, such as {3} or {4}. Or you can use a shortcut to open a specific tab that you need. Let\u2019s try the latter with {5}.
381 js.editor.navigation.search.action=Now that we\u2019re on the {0} tab, let\u2019s start typing {1} in the search bar to look up a shortcut for another useful navigation feature.
382 js.editor.navigation.go.to.declaration=Notice the {0} next to <strong>Go to Declaration or Usages</strong> \u2013 it shows you usages for the definition and vice versa. Let\u2019s close the popup, place the caret on <strong>snoopy</strong> (line 16), and hit {1} to look for its declaration.
383 js.editor.navigation.keymap.reference=Congratulations! You\u2019ve made it to the end of {0}. Print out the <a href="https://resources.jetbrains.com/storage/products/webstorm/docs/WebStorm_ReferenceCard.pdf">keymap reference</a> to have all the shortcuts handy as you make yourself at home in WebStorm. Click the button below to move to the next module.
384
385 js.editor.refactorings.title=Refactorings in a Nutshell
386 js.editor.refactorings.this={0} has a <a href=''https://www.jetbrains.com/help/webstorm/refactoring-source-code.html#ws_supported_refactorings''>number of refactorings</a> that can automatically restructure existing code without changing its behavior across the entire project. Let''s look up the list of refactorings available for the {1} parameter. To do this, press {2} or go to {3} from the main menu.
387 js.editor.refactorings.rename=With {0}, you don''t need to memorize all the refactorings the IDE has, or their shortcuts. Let''s click {1} to see one of the most popular refactorings in action.
388 js.editor.refactorings.rename.apply=Rename the {0} parameter to {1} and hit {2}. This will apply the changes across all files in the project.
389 js.editor.refactorings.shortcut=Well done! Let''s try refactoring code the other way \u2013 by using a shortcut. Place the caret on the {0} property (line 4) and press {1}.
390 js.editor.refactoring.replace=Now replace all 2 occurrences with the {0} variable named {1}.
391 js.editor.refactoring.select.expression=Let''s create a new variable, {0}, which will contain {1}. Select the {1} expression from the list and hit {2}.
392 js.editor.refactorings.next=We''ve just explored two ways to refactor code in {0}. Print out the <a href="https://resources.jetbrains.com/storage/products/webstorm/docs/WebStorm_ReferenceCard.pdf">keymap reference</a> if you prefer using shortcuts, or simply keep using the {1} menu. Click the button below to start the next lesson or use {2}.
393
394 js.testing.jest.title=Fundamentals of Testing in {0}
395 js.testing.jest.prepare=With WebStorm, all testing workflows become easier. Let\u2019s see how. For this module, we\u2019ll use <a href="https://jestjs.io/en/">Jest</a> and one of <a href="https://github.com/facebook/jest/tree/master/examples/getting-started">its sample projects</a> as an example, so please make sure you have Jest and npm/Yarn installed on your machine (see <a href="https://jestjs.io/docs/en/getting-started">this</a> webpage for more information). We\u2019ll start by creating a run/debug configuration, which is going to be Jest-specific. On the main menu, select {0} > {1}. Then click {4}, add the {2} configuration with the default parameters, and hit {3} to save it.
396 js.testing.jest.run=So, now the new {0} configuration is selected by default. Let\u2019s click the {1} ({2}) button right next to it.
397 js.testing.jest.navigate=Now we can see the {0} tool window with the test results and a stack trace for the failed tests coming from a test runner in it. Apart from simply tracking the test progress, you can do a lot of other things here. You can rerun all ({1}) or only failed ({2}) tests, view passed tests ({3}), or enable the <a href="https://blog.jetbrains.com/webstorm/2018/10/testing-with-jest-in-webstorm/#run_tests_in_watch_mode">watch mode</a> to automatically rerun tests on changes. \nYou can also quickly find a specific test in {4}. Let\u2019s try it now: place the caret anywhere in the {4} area, type {5}, and press {6} to jump to our test.
398 js.testing.jest.double.click=That\u2019s it! Use this feature whenever you need to quickly find your way through a lot of tests. Let\u2019s now double-click {0} that we\u2019ve found.
399 js.testing.jest.fix.test=By double-clicking a test in {0}, we\u2019ve jumped straight to its location in the code. If you now hover over {1}, you\u2019ll see a popup explaining why the test failed. From there, you can also debug a test if needed. \nLet\u2019s now replace the incorrect value used for {2}: on line 6, replace {3} with {4}.
400 js.testing.jest.re.run.test=Now that we have the right value for the expected result, we can rerun our test. Let\u2019s do it in a different way this time. See the {0} icon on the left of the test in the editor? This icon not only shows you the test status for the tests you\u2019ve run recently, but also lets you quickly run and debug a specific test.\n  Let\u2019s click it and select {1}.
401 js.testing.jest.success.run.coverage=Great job! Our test has successfully passed. \nLet\u2019s take a look at another handy tool. Click the {0} icon located next to the run/debug configurations menu.
402 js.testing.jest.coverage.result=This is how you can quickly build a code coverage report showing how many files were covered with tests, including the percentage of lines that were covered in those files. Now let\u2019s close the coverage report with {0}.
403 js.testing.jest.end=Congratulations! You\u2019ve made it to the end of this module. Most of what we\u2019ve learned also applies to the other test runners that {0} supports (except for code coverage and the watch mode). For more tips and tricks about testing apps with Jest, please take a look at <a href="https://blog.jetbrains.com/webstorm/2018/10/testing-with-jest-in-webstorm/">this</a> blog post. If you use other test runners, you may want to explore our <a href="https://www.jetbrains.com/help/webstorm/unit-testing-javascript.html">web help</a>.
404
405 js.debugger.module.title={0} Debugger 101
406
407 js.debugger.before.title=Before Debugging: Run/Debug Configurations
408 js.debugger.before.intro=With {0}, you can run and debug all kinds of JavaScript apps right where you write your code.\nIn this module, we\u2019ll go over some steps that will be helpful no matter what kind of code you debug. In our case, it will be a very basic <a href=''https://nodejs.org/en/''>Node.js</a> app that should compare two numbers and return {1} or {2} Please make sure Node.js is <a href=''https://nodejs.org/en/download/''>installed</a> on your machine before moving forward (for a fresh install, you\u2019ll need to restart {0}). Hit {3} if you\u2019re ready to continue.
409 js.debugger.before.describe.tool.window=Two things happened as we hit {0}. First, we ran a file using Node.js and opened the {1} tool window, which shows the results of running the code. Second, {2} created a temporary run/debug configuration so we could run a file like that. Let\u2019s hide the tool window with {3} for now and get to know run/debug configurations better.
410 js.debugger.before.save=So, these configurations serve as an entry point to running/debugging apps. They can be temporary or permanent. The main difference is that temporary ones are automatically deleted if the default limit of 5 configurations is reached. \nLet\u2019s see how you can turn a temporary configuration into a permanent one. Open the {0} drop-down menu located in the top right-hand corner and select {1}. 
411 js.debugger.before.edit=That\u2019s it! Now, what if you want to adjust the settings of this new run/debug configuration or use another one? Open the {0} menu again and click {1}.
412 js.debugger.before.manage=This is a place for managing run/debug configurations. To add a new one, hit {0}, select the desired configuration type, and specify the settings based on your project/configuration type. To fine-tune an existing one, you can click its name and update what\u2019s needed.\nTake some time to explore what can be found here and close the window once you\u2019re ready to move next.
413 js.debugger.before.next=That\u2019s it for this lesson. To start the next one, click the button below or use {0}.
414
415 js.debugger.part.1.title=Debugging Code. Part I
416 js.debugger.part.1.start=Now that we have a run/debug configuration in place, let\u2019s see how to work with the built-in debugger. \nFirst, let\u2019s run our code one more time to examine what it returns as we didn''t focus on this in the previous lesson. Click the {0} button located next to the drop-down with configurations to run the currently selected one.
417 js.debugger.part.1.gutter=The numbers we\u2019re comparing, {0} and {1}, are not equal, so we should\u2019ve got {2} when running the code. Let\u2019s find out why we got {3} instead. On line 1, click the left editor gutter (empty space) between #1 and the code to put a breakpoint.
418 js.debugger.part.1.set.breakpoint=So, we can use breakpoints to pause the execution of the app. The red circle you see on the left-hand editor gutter is what a breakpoint looks like in WebStorm. If you click on it again, it will be removed. You can also right-click on it to customize its behavior, e.g. set a condition for it. Let\u2019s hit the {0} button located at the top right-hand corner (or press {1}) to move next.
419 js.debugger.part.1.tool.window=Meet the {0} tool window. On its left side, you can find icons for stopping/rerunning configurations, and managing breakpoints. At its top, you can see a few tabs and a bunch of icons for stepping through the code. \nThe {1} tab we''re on is where most of the work is done. On the right, you can see all the {2} grouped by scopes, along with their values. The {3} view shows the call stack. If you go through it, you\u2019ll see the app state at every point of the execution path. Now switch to the {4} tab.
420 js.debugger.part.1.scripts.tab=The {0} tab shows the messages logged by an app, including errors. When debugging Node.js apps, WebStorm also shows the {1} tab, where you can run JavaScript code snippets and view the console messages. Switch to the {2} tab to continue.
421 js.debugger.part.1.next=The {0} tab lists all the files loaded into the currently running process. You can see the content of any file by double-clicking on it. To move to the second part of this lesson, click the button below or use {1}.
422         
423 js.debugger.part.2.title=Debugging Code. Part II
424 js.debugger.part.2.step.into=<strong>Important</strong>: Please make sure that there\u2019s a breakpoint on line 1 and that the debugger is launched ({0}) and opened on the {1} tab before moving forward.\nLet''s continue with locating a bug in our code and learn a few more things that come in handy when debugging in {2}.To better understand how our code is executed, we could put a few more breakpoints in it and then move from one to another using {3} button ({4}), but there\u2019s a faster way. Let\u2019s step to the next executed line by pressing {5} and using {6} ({7}).
425 js.debugger.part.2.buttons=Depending on the situation, you may also like {0} ({1}), which moves the execution in the current file, line by line, without stepping into any function calls. {2} ({3}) lets you select the chained or nested call to step into. Finally, {4} ({5}) finishes the execution of the current function and stops at the next statement after the call. \nNow, what if we want to check the value of an expression? {6} lets you do it quickly with the {7} popup. Press {8} to call it.
426 js.debugger.part.2.evaluate=Let''s add {0} as an expression and hit {1}. Look at the result: it equals {2}. This is where the problem lies. In order for the function to catch different numbers, we need to slightly change the expression so that its result would equal {3}.\nNow let''s close the popup and fix the problem we''ve found in the code. Inside {4} on line 2, replace {5} with {6}.
427 js.debugger.part.2.stop=Finally, let\u2019s learn how to stop the debugger when you no longer need it. First, click the breakpoint we added to remove it. Then, stop the debugger with {0} ({1}) and close its tool window by pressing {2}.
428 js.debugger.part.2.end=Congratulations! You\u2019ve made it to the end of {0} and learned some basic ways to debug all kinds of apps. If you\u2019d like, you can run the code one more time to confirm that everything works fine now. To dive deeper into debugging specific types of apps, take a look at our <a href=''https://www.jetbrains.com/help/webstorm/2019.2/debugging-code.html''>web help</a> and <a href=''https://blog.jetbrains.com/webstorm/tag/debug/''>blog posts</a>. Click the button below to move to the next module.