Let's say I have a bunch of functions below:
library.object1.function1()
library.object1.function2()
library.object2.function1()
library.object2.function2()
library.object3.function1()
library.object3.function2()
With what they provide in current custom snippet, when I type lib, it will show all those above functions, which will be a mess if there are too many functions.
I want to make my snippets work like what they did in default code completion:
When I type lib, it only shows:
library
When I type library., it shows:
object1
object2
object3
When I type library.object1., it shows
function1()
function2()
Also, if I type lib, and leave it there, then comeback and add rary, the snippet doesn't work at all, I want it to continue the completion.
Is there a way to achieve it?
I think the closest you can get is something like this (using javascript.json snippet file as an example):
"my library": {
"prefix": "lib",
"body": [
"library.${1|object1,object2,object3|}.${2|function1,function2,function3,function4|}()",
],
"description": "my library functions"
}
With that, when you type lib you get only the library suggested completion. Tab and you will get all the object choices you included in the snippet in the suggestion panel. Tab again and will get the function options that you listed in the snippet.
See snippet choices.
Related
I am working on a VsCode extension in that I want to provide custom snippets for code completion.
I know about the option of using snippet json files directly, however those have the limitation of not being able to utilize the CompletionItemKind property that determines the icon next to the completion suggestion in the pop-up.
My issue:
If I implement a simple CompletionItemProvider like this:
context.subscriptions.push(
vscode.languages.registerCompletionItemProvider(
{scheme:"file",language:"MyLang"},
{
provideCompletionItems(document: vscode.TextDocument, position: vscode.Position) {
let item = new vscode.CompletionItem('test');
item.documentation = 'my test function';
item.kind = vscode.CompletionItemKind.Function;
return [item];
}
}
)
)
then the original VsCode IntelliSense text suggestions are not shown anymore, only my own. Should I just return a kind of an empty response, like
provideCompletionItems(document: vscode.TextDocument, position: vscode.Position) {
return [null|[]|undefined];
}
the suggestions appear again as they should. It seems to me that instead of merging the results of the built-in IntelliSense and my own provider, the built-in ones get simply overridden.
Question:
How can I keep the built-in IntelliSense suggestions while applying my own CompletionItems?
VsCode Version: v1.68.1 Ubuntu
I seem to have found the answer for my problem, so I will answer my question.
Multiple providers can be registered for a language. In that case providers are sorted
by their {#link languages.match score} and groups of equal score are sequentially asked for
completion items. The process stops when one or many providers of a group return a
result.
My provider seems to provide results that are just higher scored than those of IntelliSense.
Since I didn't provide any trigger characters, my CompletionItems were comteping directly with the words found by the built-in system by every single pressed key and won.My solution is to simply parse and register the words in my TextDocument myself and extend my provider results by them. I could probably just as well create and register a new CompletionItemProvider for them if I wanted to, however I decided to have a different structure for my project.
Im using Ember with VS Code.
What I need is to generate import string on a fly when I encounter dependency. For example I write someting like:
#tracked isLarge = false;
But I don’t have “#tracked” imported yet. So the otion could be to set the coursor on #tracked, press something like “Action + .” and pick “generate import”. It should generate import string:
import { tracked } from '#ember/tracking';
But it doesn’t work out of the box. How can I do that?
UPDATE: the same question about:
go to definition
go to implementation
cmd+click to navigate to implementation/component
You can use the extension My Code Actions
You can create actions that just insert the text independent of an error.
"my-code-actions.actions": {
"[javascript]": {
"import tracked": {
"where": "insertAfter",
"insertFind": "^import",
"text": "import { tracked } from '#ember/tracking';\n"
}
}
}
The key combo to use is the Code Action combo: Ctrl+.
If you get a diagnostic (PROBLEM panel, and squiggle) you can use that to further customize the action and you can use text from the diagnostics message.
I'm current adding the possibility to make multiple edits in an action and to use further customization and generalization.
"Ember Language Server" brings some solution. But it works mostly with library code that has .d.ts typings.
In case of custom JS code it still doesn't work.
So there is no straight solution. Only 2 ways:
Write .d.ts typing for custom code JS files
Move project to typescript
I wanted to know if it is possible to trigger a user defined custom snippet when I create a file in vscode.
I started learning Golang recently and noticed that there is some boilerplate code that goes into creating the main.go file.
So I created my custom snippet for it and now now I can trigger the snippet manually and save me some keystrokes of typing.
I wanted to go one step further, so that whenever I create a new file named main.go from within VsCode, it should automatically fire that snippet and insert the biolerplate code for me, without me having to manually trigger the snippet.
Is this even possible ?
Check out this extension: Auto Snippet:
With this in your settings.json:
"autoSnippet.snippets": [
{ "pattern": "**/main.go", "snippet": "main-go-template" },
],
[Note that the example settings in the extension docs has a few syntax errors - use my example above - I have filed an issue with the creator.]
And then your snippet
"main-go-template": {
"prefix": "zz",
"body": [
... // you can use tabstops and transforms just like regular snippets
]
"description": "javascript template"
}
Then creating a new main.go file or opening an empty one should trigger the snippet.
It is a good idea to reload vscode whenever you make a change to this extension's settings.
Here is a demo of a gulpfile with common boilerplate:
Also see this extension https://marketplace.visualstudio.com/items?itemName=bam.vscode-file-templates
I would like to add symbol support for PowerShell to VS Code but I'm not finding any docs on the code.visualstudio.com/docs site.
Also, is it possible to do this for a language like PowerShell that, for the moment, will only work on Windows? Is there a way to light up symbol support on Windows only?
BTW I've added a bunch of PowerShell snippets that I'm in the process of trying to get integrated into VS Code. Any help on how to get these snippets into the product would be appreciated as well? I did submit an issue on the snippets, suggesting that the team put these into VS Code.
There is currently no documentation for the plugin API. It's too early for this as the API is still changing with every minor release. The VSCode team is focused on providing a stable plugin API. There will be a documentation about it when it's done.
Nevertheless it is already possible to add a new language plugin or extending an exisiting one. Take a look on this short description on how to add declaration support for a new language: Create Custom Language in Visual Studio Code
You could add symbol support in a similar way. What you need is something like an abstract syntax tree builder for powershell scripts and an application or a javascript module that is able to process a JSON request in order to provide the correct symbols. An example request for outline support is this:
{
"seq":442,
"type":"request",
"command":"navbar",
"arguments":
{
"file":"c:/Users/C/Documents/projects/MyProject/MyFile.xxx"
}
}
A response could look like that:
{
"seq":442,
"type":"response",
"command":"navbar",
"request_seq":442,
"success":true,
"body":[
{
"text":"TObjA",
"kind":"class",
"kindModifiers":"",
"spans":[
{
"start":{
"line":10,
"offset":3
},
"end":{
"line":16,
"offset":4
}
}
],
"childItems":[
]
},
{
"text":"DoSomething",
"kind":"method",
"kindModifiers":"",
"spans":[
{
"start":{
"line":20,
"offset":1
},
"end":{
"line":27,
"offset":4
}
}
],
"childItems":[
]
},
]
}
I'm not sure what do you mean with "symbol support". Is it something like "jump to symbol inside the current file" using CTRL+Shift+O? Then you are looking for outlineSupport.
Is it something like "find a symbol in any file" using CTRL+P, #? Then you are looking for navigateTypesSupport.
Copy the needed .js file from the vs.langauage.csharp.o folder to the vs.langauage.powershell folder and register the support in powershellMain.js as it is done in omnisharpMain.js.
If you want to register the new support only on Windows then you can do it like this:
var isWin = /^win/.test(process.platform);
if(isWin)
monaco.Modes.NavigateTypesSupport.register('powershell', new navigateTypesSupport_1.default(ModelService, server));
I hope this helps for the moment. Don't forget to save your changed plugins in a different folder. VSCode often deletes changes in the plugin folders on update.
I'm writing a sort of dashboard-esque program in Python to make tasks that I do frequently here at work a little better/easier.
What I currently have set up is an actions module. actions contains an actionlist that is a list of classes. Each of my classes has a .title, .icon (base-64 encoded string for use with tkinter.PhotoImage), and a .action function.
Using tkinter I create a new button for each of these actions, with the appropriate icon, text, and the command of the button set to the .action. So far it works quite nicely, but if I want to create a new action, I have to go into my actions module, create a new class, and then put that class in my actionlist.
What I would like to do is be able to dynamically generate this actionlist based on what files are present in my module. So I would like to have something like this:
actions/
__init__.py
someaction.py
do_another_thing.py
do_all_the_things.py
chop_down_the_tree_with_a_herring.py
And whenever I would like to create a new action, I just put a .py script in my actions folder and then it would automagically generate the list of actions for me, however I can't seem to find any good way of creating this list. I've thought of using something like os.listdir to get the list of files, but neither that or the other methods of introspection (dir, and inspect.getmembers) seemed to have quite what I wanted. Of course, it's possible that I just missed the features that I need.
In any case, pointers in the right direction would be great. Thanks!
SOLUTION:
Lennart's solution, with some slight adaptations worked for me.
Inside my __init__.py I have the following code:
plugins = []
__all__ = [
'do_all_the_things',
'do_another_thing',
'someaction',
'chop_down_the_tree_with_a_herring',
'seek_the_grail',
]
Then inside each of my plugins I have something like this:
from actions import plugins
class SeekTheGrail:
def __init__(self):
self.text = 'We Seek The Grail'
self.icon = b'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'
def action(self):
print('I am Arthur, King of the Britons!')
plugins.append(SeekTheGrail())
and now I just have to modify the __all__ collection when I want to add or remove the actions from loading.
The way to create plugins is to have a plugin registry, and register plugins there. This can be done from the amazingly simple, like just defining a global list in a module:
plugins = []
And then registering the plugins with:
class APlugin(object):
blahblah
from themodule import plugins
plugin.add(APlugin())
This can be made more flexible by having types of plugins and registering them with a name etc. But then you are on the path to complexity, and then you might want to take a look at the Zope Component Architecture, which simply speaking is a very powerful system for making your application pluggable.
It should be noted that in any case it's best to have a list of what plugins should be activated instead of auto-discovering them. This can be as simple as a list in a text file or a setting in a config file. This enables you to easily activate and disactivate the plugins.
You can use something like this:
actions = {}
for filename in os.listdir('somepath/actions'):
actions[filename] = __import__('actions.'+filename)
for name,class in actions:
createButton(name,class)
Where in the createButton you create your tk_inter button and assign it the functions from the class. The important bit i suppose is that you can use __import__ to import a class using its string name and save it as a variable.