Test: Enable emmet for other languages #9500

[egamma]

Test for #9500

• Windows and Mac @ramya-rao-a, @waderyan
• Any OS @aeschli

Complexity 1

You can enable emmet for other languages both as a user and as a language contributor.

Enable emmet for a new language as a user.

As a user you can define an emmet syntax profile and associate an emmet supported profile to a language. For a list of supported emmet profiles see #9500 (comment). For example to associate java with the html syntax profile you can define the setting:

{
  "emmet.syntaxProfiles": {
    "java": "html"
  }
}

• Verify that emmet abbreviations are expanded inside an java file using the html profile.

Enable emmet as a language provider

As a language provider you can associate your language with an emmet syntax profile by adding an emmet supported profile in the scope name of the grammar (textmate language grammar). For example, define the scope of you

        "grammars": [
            {
                "language": "foo",
                "scopeName": "text.html.foo"
            }
        ]

Define a language foo as shown above.

• Verify that in file of type foo you emmet abbreviations using the html support.
• Verify that you get emmet abbreviations independent of where html appears in the scope name.

[waderyan]

@egamma

Verify that emmet abbreviations are expanded inside an html file using the html profile.

Do you mean "inside a Java file using the html profile"?

If not I could use some clarification on how to test part one.

If you did mean Java, these are the steps I took.

Add the following to settings.json

    "emmet.syntaxProfiles": {
        "java": "html"
    }

Create test.java. Type ! and tab to see emmet html output.

[waderyan]

For reference this is what I put in the extension's package.json

"contributes": {
        "languages": [
            {
                "id": "foo",
                "extensions": [".foo"]
            }
        ],
        "grammars": [
            {
                "language": "foo",
                "scopeName": "text.foo.html",
                "path": "grammar.tmLanguage"
            }
        ]
    },

And here is my sample grammar.

{  
    scopeName = 'source.untitled';

    fileTypes = ( );
    foldingStartMarker = '\{\s*$';
    foldingStopMarker = '^\s*\}';
    patterns = (
        {  name = 'keyword.control.untitled';
            match = '\b(if|while|for|return)\b';
        },
        {  
            name = 'string.quoted.double.untitled';
            begin = '"';
            end = '"';
            patterns = ( 
            {  
                name = 'constant.character.escape.untitled';
                match = '\\.';         
            }
        );
        },
        );
}

[mrmlnc]

@waderyan,

Create test.java. Type ! and tab to see emmet html output.

Yes, you're right.

Correct result:

scopeName": "text.foo.html",

For correct results, you should use "text.html.foo".

P.S.: for testing you can use any extension that provides the HTML syntax (or any language from #9500 (comment)). For example: https://github.com/mrmlnc/vscode-vash.

Correct result:

[dbaeumer]

@aeschli @ramya-rao-a friendly reminder to test this item.

[aeschli]

Naming my grammar's scope in a specific way so that I get emmet proposals seems like hacky solution to me. It only is feasible when my language is a subset of that language, given that the scope name also has an impact on colorization (at least as long as we flatten our scopes).
A more explicit solution would be better.

[ramya-rao-a]

@egamma

Verify that you get emmet abbreviations independent of where html appears in the scope name

The newly defined language only gets emmet abbreviations if the scope name was text.html.foo. They do not work when html is moved around in the scopename. Which makes sense because scopename is supposed to have hierarchically defined languages from left to right

scopeName (line 1) — this should be a unique name for the grammar, following the convention of being a dot-separated name where each new (left-most) part specializes the name. Normally it would be a two-part name where the first is either text or source and the second is the name of the language or document type. But if you are specializing an existing type, you probably want to derive the name from the type you are specializing. For example Markdown is text.html.markdown and Ruby on Rails (rhtml files) is text.html.rails. The advantage of deriving it from (in this case) text.html is that everything which works in the text.html scope will also work in the text.html.«something» scope (but with a lower precedence than something specifically targeting text.html.«something»).

From: https://manual.macromates.com/en/language_grammars

[ramya-rao-a]

@egamma @mrmlnc Any thoughts on @aeschli's comment above?