├── .gitignore
├── icon.png
├── src
    ├── editor
    │   ├── commands
    │   │   ├── ICommand.ts
    │   │   ├── BlockCommentCommand.ts
    │   │   └── LineCommentCommand.ts
    │   └── providers
    │   │   └── CfmlSnippetsCompletionProvider.ts
    ├── test
    │   ├── index.ts
    │   └── ScriptContext.test.ts
    ├── cfmlMain.ts
    ├── parser
    │   └── ScriptContext.ts
    └── data
    │   └── CfmlSnippetsDataSource.ts
├── tslint.json
├── .vscodeignore
├── .vscode
    ├── settings.json
    ├── tasks.json
    └── launch.json
├── tsconfig.json
├── resources
    └── test
    │   └── ScriptContext
    │       ├── cfscript_test.cfc
    │       └── cfml_test.cfc
├── cfml.configuration.json
├── LICENSE
├── README.md
├── CHANGELOG.md
├── vsc-extension-quickstart.md
├── package.json
├── Gruntfile.js
└── themes
    ├── cfml_dark.json
    └── cfml_light.json


/.gitignore:
--------------------------------------------------------------------------------
1 | out
2 | node_modules
3 | .vscode-test/
4 | *.vsix
5 | *.tmp
6 | .vs/


--------------------------------------------------------------------------------
/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ilich/vscode-coldfusion/HEAD/icon.png


--------------------------------------------------------------------------------
/src/editor/commands/ICommand.ts:
--------------------------------------------------------------------------------
1 | "use strict";
2 | export interface ICommand {
3 |     execute(): void;
4 | }
5 | 


--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
1 | {
2 |     "defaultSeverity": "error",
3 |     "extends": [
4 |         "tslint:recommended"
5 |     ],
6 |     "jsRules": {},
7 |     "rules": {},
8 |     "rulesDirectory": []
9 | }


--------------------------------------------------------------------------------
/.vscodeignore:
--------------------------------------------------------------------------------
 1 | .vs/**
 2 | .vscode/**
 3 | .vscode-test/**
 4 | out/test/**
 5 | out/**/*.map
 6 | src/**
 7 | .gitignore
 8 | tsconfig.json
 9 | tslint.json
10 | vsc-extension-quickstart.md
11 | Gruntfile.js
12 | package-lock.json
13 | resources/test/**
14 | *.tmp


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | // Place your settings in this file to overwrite default and user settings.
2 | {
3 |     "files.exclude": {
4 |         "out": false // set this to true to hide the "out" folder with the compiled JS files
5 |     },
6 |     "search.exclude": {
7 |         "out": true // set this to false to include "out" folder in search results
8 |     }
9 | }


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "module": "commonjs",
 4 |         "target": "es6",
 5 |         "outDir": "out",
 6 |         "lib": [
 7 |             "es6"
 8 |         ],
 9 |         "sourceMap": true,
10 |         "rootDir": "src"
11 |     },
12 |     "exclude": [
13 |         "node_modules",
14 |         ".vscode-test"
15 |     ]
16 | }


--------------------------------------------------------------------------------
/resources/test/ScriptContext/cfscript_test.cfc:
--------------------------------------------------------------------------------
 1 | component {
 2 |     this.baseGreeting = "Hello, ";
 3 | 
 4 |     public string function getFullName (String firstName, String lastName) {
 5 |     	var fullName = arguments.firstName & " " & arguments.lastName;
 6 |         return fullName;
 7 |     }
 8 | 
 9 |     public string function getGreeting (String firstName, String lastName) {
10 |     	var fullName = getFullName(argumentCollection=arguments);
11 |     	var greeting = this.baseGreeting & fullName;
12 | 
13 |         return greeting;
14 |     }
15 | }


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | // See https://go.microsoft.com/fwlink/?LinkId=733558
 2 | // for the documentation about the tasks.json format
 3 | {
 4 |     "version": "2.0.0",
 5 |     "tasks": [
 6 |         {
 7 |             "type": "npm",
 8 |             "script": "watch",
 9 |             "problemMatcher": "$tsc-watch",
10 |             "isBackground": true,
11 |             "presentation": {
12 |                 "reveal": "never"
13 |             },
14 |             "group": {
15 |                 "kind": "build",
16 |                 "isDefault": true
17 |             }
18 |         }
19 |     ]
20 | }


--------------------------------------------------------------------------------
/cfml.configuration.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "comments": {
 3 |         "lineComment": "//",
 4 |         "blockComment": [ "/*", "*/" ]
 5 |     },
 6 |     "brackets": [
 7 |         ["{", "}"],
 8 |         ["[", "]"],
 9 |         ["(", ")"]
10 |     ],
11 |     "autoClosingPairs": [
12 |         ["{", "}"],
13 |         ["[", "]"],
14 |         ["(", ")"],
15 |         ["\"", "\""],
16 |         ["'", "'"],
17 |         ["#", "#"]
18 |     ],
19 |     "surroundingPairs": [
20 |         ["{", "}"],
21 |         ["[", "]"],
22 |         ["(", ")"],
23 |         ["\"", "\""],
24 |         ["'", "'"],
25 |         ["#", "#"]
26 |     ]
27 | }
28 | 


--------------------------------------------------------------------------------
/src/test/index.ts:
--------------------------------------------------------------------------------
 1 | //
 2 | // PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING
 3 | //
 4 | // This file is providing the test runner to use when running extension tests.
 5 | // By default the test runner in use is Mocha based.
 6 | //
 7 | // You can provide your own test runner if you want to override it by exporting
 8 | // a function run(testRoot: string, clb: (error:Error) => void) that the extension
 9 | // host can call to run the tests. The test runner is expected to use console.log
10 | // to report the results back to the caller. When the tests are finished, return
11 | // a possible error to the callback or null if none.
12 | 
13 | import * as testRunner from "vscode/lib/testrunner";
14 | 
15 | // You can directly control Mocha options by uncommenting the following lines
16 | // See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
17 | testRunner.configure({
18 |     ui: "tdd", 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
19 |     useColors: true, // colored output from test results
20 | });
21 | 
22 | module.exports = testRunner;
23 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | // A launch configuration that compiles the extension and then opens it inside a new window
 2 | {
 3 |     "version": "0.1.0",
 4 |     "configurations": [
 5 |         {
 6 |             "name": "Launch Extension",
 7 |             "type": "extensionHost",
 8 |             "request": "launch",
 9 |             "runtimeExecutable": "${execPath}",
10 |             "args": ["--extensionDevelopmentPath=${workspaceRoot}" ],
11 |             "stopOnEntry": false,
12 |             "sourceMaps": true,
13 |             "outFiles": [ "${workspaceRoot}/out/**/*.js" ],
14 |             "preLaunchTask": "npm: watch"
15 |         },
16 |         {
17 |             "name": "Launch Tests",
18 |             "type": "extensionHost",
19 |             "request": "launch",
20 |             "runtimeExecutable": "${execPath}",
21 |             "args": ["--extensionDevelopmentPath=${workspaceRoot}", "--extensionTestsPath=${workspaceRoot}/out/test" ],
22 |             "stopOnEntry": false,
23 |             "sourceMaps": true,
24 |             "outFiles": [ "${workspaceRoot}/out/test/**/*.js" ],
25 |             "preLaunchTask": "npm: watch"
26 |         }
27 |     ]
28 | }
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Ilya Verbitskiy
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/resources/test/ScriptContext/cfml_test.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent displayName="Simple HelloWorld component" output="false">
 2 | 
 3 |     <cffunction name="sayHello" access="remote" output="false" returnType="string">
 4 |         <cfargument name="nom" required="true" type="string" />
 5 |         <cfreturn "Hello, " & trim(arguments.nom) & "." />
 6 |     </cffunction>
 7 | 
 8 |     <cffunction name="sampleCFScript" access="remote" output="false" returnType="string">
 9 |         <cfargument name="nom" required="true" type="string" />
10 | 
11 |         <cfquery name = "SampleQuery" datasource = "MyTestDataSource">
12 |             SELECT FirstName, LastName
13 |             FROM Customers
14 |             WHERE ID > 1000
15 |         </cfquery>
16 | 
17 |         <CFSCRIPT>
18 |             x = 1;
19 |             y = 20;
20 |             result = x + y;
21 |             writeDump(x); 
22 |         </cfscript>
23 |     </cffunction>
24 | 
25 |     <cffunction name="sampleCFQuery" access="remote" output="false" returnType="string">
26 |         <cfquery name = "SampleQuery" datasource = "MyTestDataSource">
27 |             SELECT FirstName, LastName
28 |             FROM Customers
29 |             WHERE ID > 1000
30 |         </CFQUERY>
31 |     </cffunction>
32 | 
33 | </cfcomponent>


--------------------------------------------------------------------------------
/src/editor/commands/BlockCommentCommand.ts:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | import * as vscode from "vscode";
 3 | import { LANGUAGE_ID } from "../../cfmlMain";
 4 | import { ScriptContext } from "../../parser/ScriptContext";
 5 | import { ICommand } from "./ICommand";
 6 | 
 7 | export class BlockCommentCommand implements ICommand {
 8 |     public execute() {
 9 |         const editor = vscode.window.activeTextEditor;
10 |         const context = new ScriptContext(editor.document);
11 | 
12 |         let position = editor.selection.start;
13 | 
14 |         // first we should check if current selection starts with </cfscript>.
15 |         // in this case we should start checking context after </cfscript> tag.
16 |         // this is a workaround to support block comments.
17 |         const selectedText = editor.document.getText(editor.selection);
18 |         if (/[\s\t]*<\/[c]?[f]?script>/ig.test(selectedText)) {
19 |             const line = editor.document.lineAt(position.line);
20 |             position = line.range.end;
21 |         }
22 | 
23 |         let config: vscode.LanguageConfiguration = {
24 |             comments: {
25 |                 blockComment: [ "/*", "*/" ],
26 |             },
27 |         };
28 | 
29 |         if (!context.isScript(position) && !context.isCFQuery(position)) {
30 |             config = {
31 |                 comments: {
32 |                     blockComment: [ "<!---", "--->" ],
33 |                 },
34 |             };
35 |         }
36 | 
37 |         vscode.languages.setLanguageConfiguration(LANGUAGE_ID, config);
38 |         vscode.commands.executeCommand("editor.action.blockComment");
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/cfmlMain.ts:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | import * as vscode from "vscode";
 3 | import { BlockCommentCommand } from "./editor/commands/BlockCommentCommand";
 4 | import { LineCommentCommand } from "./editor/commands/LineCommentCommand";
 5 | import { CfmlSnippetsCompletionProvider } from "./editor/providers/CfmlSnippetsCompletionProvider";
 6 | 
 7 | export const LANGUAGE_ID = "cfml";
 8 | 
 9 | function isEnabled(paramName: string, defaultValue: boolean = true): boolean {
10 |     let enabled: boolean;
11 |     const config = vscode.workspace.getConfiguration("cfml");
12 |     if (config === null) {
13 |         enabled = defaultValue;
14 |     } else {
15 |         enabled = config.get(paramName);
16 |     }
17 | 
18 |     return enabled;
19 | }
20 | 
21 | function activateCommentsSupport(context: vscode.ExtensionContext) {
22 |     const lineComment = new LineCommentCommand();
23 |     const toggleLineCommentCommand = vscode.commands.registerCommand(
24 |         "cfml.toggleLineComment",
25 |         lineComment.execute);
26 |     context.subscriptions.push(toggleLineCommentCommand);
27 | 
28 |     const blockComment = new BlockCommentCommand();
29 |     const toggleBlockCommentCommand = vscode.commands.registerCommand(
30 |         "cfml.toggleBlockComment",
31 |         blockComment.execute);
32 |     context.subscriptions.push(toggleBlockCommentCommand);
33 | }
34 | 
35 | function activateSnippets(context: vscode.ExtensionContext) {
36 |     if (!isEnabled("snippets.enabled")) {
37 |         return;
38 |     }
39 | 
40 |     const snippetsProvider = new CfmlSnippetsCompletionProvider();
41 |     const provider = vscode.languages.registerCompletionItemProvider(LANGUAGE_ID, snippetsProvider);
42 |     context.subscriptions.push(provider);
43 | }
44 | 
45 | export function activate(context: vscode.ExtensionContext) {
46 |     activateCommentsSupport(context);
47 |     activateSnippets(context);
48 | }
49 | 
50 | export function deactivate() {
51 |     // TBD. It is not used at the moment.
52 | }
53 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Project discontinued
 2 | 
 3 | Unfortunately, I won't be able to continue development on ColdFusion extension, due to lack of time. I suggest you give https://github.com/KamasamaK/vscode-cfml a try instead.
 4 | 
 5 | ## Acknowledgements
 6 | 
 7 | * [`coldfusion.tmbundle`](https://github.com/textmate/coldfusion.tmbundle) on which the syntax highlighting is based.
 8 | * [`vscode-cfml`](https://github.com/KamasamaK/vscode-cfml), [`sublimetext-cfml`](https://github.com/jcberquist/sublimetext-cfml), [`sublimetext-coldfusion`](https://github.com/SublimeText/ColdFusion) and [Ortus Solutions](https://www.ortussolutions.com) as inspiration for some of the features and CFML parser regular expressions.
 9 | * [`cfdocs`](https://github.com/foundeo/cfdocs) for documentation and the source for snippets.
10 | 
11 | ## Contributors
12 | 
13 | There were many contributors to the project. Thank you all for your help! You can find the list of contributors on https://github.com/ilich/vscode-coldfusion/pulls and https://github.com/ilich/vscode-coldfusion/issues pages.
14 | 
15 | ## Features
16 | 
17 | * **Syntax highlighting**
18 | 
19 | * **`CFML Light` theme with CFML tags coloring support**.
20 | The theme is based on VS Code `Light+ (default light)` theme. The theme adds special color for standard CFML tags to improve code readability.
21 | 
22 | * **`CFML Dark` theme with CFML tags coloring support**.
23 | The theme is based on VS Code `Dark+ (default dark)` theme. The theme adds special color for standard CFML tags to improve code readability.
24 | 
25 | * **Build-in CFML tags and functions snippets**.
26 | 
27 | ## Commands
28 | 
29 | Used in Command Palette (Win/Linux: `CTRL+SHIFT+P`; Mac: `CMD+SHIFT+P`). Can also be bound to Keyboard Shortcuts (Win/Linux: `CTRL+K CTRL+S`; Mac: `CMD+K CMD+S`).
30 | 
31 | - CFML: Toggle Line Comment (`CTRL+/`)
32 | - CFML: Toggle Block Comment (`SHIFT+ALT+A`)
33 | 
34 | ## Settings
35 | 
36 | The following are the configurable Settings (Win/Linux: `CTRL+,`; Mac: `CMD+,`) that this extension contributes to VS Code:
37 | 
38 | - `cfml.snippets.enabled`: Enable built-in CFML tags and functions snippets. [*Default*: `true`]


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | All notable changes to this project will be documented in this file.
 3 | 
 4 | The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 5 | and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 6 | 
 7 | ## v1.0.1 - 2018-01-01
 8 | ### Added
 9 | - CFML tags support to CFScript context.
10 | ### Changed
11 | - Fixed https://github.com/ilich/vscode-coldfusion/issues/36.
12 | 
13 | ## v1.0.0 - 2017-12-29
14 | ### Added
15 | - `CFML Light` and `CFML Dark` themes with CFML tags support.
16 | - `cfml.snippets.enabled` setting.
17 | ### Changed
18 | - Changed language ID to be `cfml`.
19 | - Updated syntax highlighting based on the latest TextMate ColdFusion bundle. New syntax file understands built-in CFML tags.
20 | - Updated CFML snippets using https://cfdocs.org/ content.
21 | - Line comments (`CTRL+/`) and block comments (`SHIFT+ALT+A`) take current context into account.
22 | - Fixed https://github.com/ilich/vscode-coldfusion/issues/32.
23 | - Fixed https://github.com/ilich/vscode-coldfusion/issues/27.
24 | 
25 | ## v0.0.11 - 2017-08-25
26 | ### Added
27 | - `WriteDump` snippet.
28 | ### Changed
29 | - Use CFML comments by default instead of CFScript comments.
30 | 
31 | ## v0.0.10 - 2017-07-18
32 | ### Changed
33 | - Use `lang-cfml` as the language identifier for the extension due some other extension compatibility issues.
34 | 
35 | ## v0.0.9 - 2017-07-17
36 | ### Changed
37 | - Use `cfml` instead of `lang-cfml` as the language identifier for the extension.
38 | 
39 | ## v0.0.8 - 2017-07-16
40 | ### Added
41 | - Extension logo.
42 | 
43 | ## v0.0.7 - 2017-07-16
44 | ### Changed
45 | - Updated syntax highlighting based on SublimeText bundle.
46 | 
47 | ## v0.0.6 - skipped
48 | 
49 | ## v0.0.5 - skipped
50 | 
51 | ## v0.0.4 - 2016-11-23
52 | ### Added
53 | - Language configuration: comments support.
54 | 
55 | ## v0.0.3 - 2016-02-16
56 | ### Changed
57 | - Updated syntax highlighting and added snippets TextMate ColdFusion bundle.
58 | 
59 | ## v0.0.2 - 2016-02-14
60 | ### Changed
61 | - Syntax highlighting and refactoring.
62 | 
63 | ## v0.0.1 - 2015-11-29
64 | ### Added
65 | - Initial Release.


--------------------------------------------------------------------------------
/src/editor/commands/LineCommentCommand.ts:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | import * as vscode from "vscode";
 3 | import { LANGUAGE_ID } from "../../cfmlMain";
 4 | import { ScriptContext } from "../../parser/ScriptContext";
 5 | import { ICommand } from "./ICommand";
 6 | 
 7 | export class LineCommentCommand implements ICommand {
 8 |     public execute() {
 9 |         const editor = vscode.window.activeTextEditor;
10 |         const context = new ScriptContext(editor.document);
11 |         const line = editor.document.lineAt(editor.selection.start.line);
12 |         let position = line.range.end;
13 | 
14 |         // first we should check if current selection starts with </cfscript> or </script>.
15 |         // in this case we should start checking context after </cfscript> tag.
16 |         // the same is applicable for <cfscript> and <script> tags.
17 |         if (/[\s\t]*<\/[c]?[f]?script>/ig.test(line.text)) {
18 |             position = line.range.end;
19 |         } else if (/[\s\t]*<[c]?[f]?script>/ig.test(line.text)) {
20 |             position = line.range.start;
21 |         }
22 | 
23 |         let executeCommand = true;
24 |         const command = "editor.action.commentLine";
25 |         let config: vscode.LanguageConfiguration = {
26 |             comments: {
27 |                 lineComment: "//",
28 |             },
29 |         };
30 | 
31 |         if (context.isCFQuery(position)) {
32 |             // this is cfquery
33 |             config = {
34 |                 comments: {
35 |                     lineComment: "--",
36 |                 },
37 |             };
38 |         } else if (!context.isScript(position)) {
39 |             // it is not a cfquery or cfscript or script tag
40 |             // apply cfml comment manually
41 |             executeCommand = false;
42 |             editor.edit((builder: vscode.TextEditorEdit) => {
43 |                 const range = line.range;
44 |                 builder.insert(range.start, "<!--- ");
45 |                 builder.insert(range.end, " --->");
46 |             });
47 |         }
48 | 
49 |         if (executeCommand) {
50 |             vscode.languages.setLanguageConfiguration(LANGUAGE_ID, config);
51 |             vscode.commands.executeCommand(command);
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/parser/ScriptContext.ts:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | import * as vscode from "vscode";
 3 | 
 4 | export class ScriptContext {
 5 |     private document: vscode.TextDocument;
 6 |     private cfqueryBegin = new RegExp("<cfquery", "ig");
 7 |     private cfqueryEnd = new RegExp("<\/cfquery", "ig");
 8 |     private cfscriptBegin = new RegExp("<cfscript", "ig");
 9 |     private cfscriptEnd = new RegExp("<\/cfscript", "ig");
10 |     private scriptBegin = new RegExp("<script", "ig");
11 |     private scriptEnd = new RegExp("<\/script", "ig");
12 |     private anyCfml = new RegExp("<cf", "ig");
13 | 
14 |     constructor(document: vscode.TextDocument) {
15 |         this.document = document;
16 |     }
17 | 
18 |     public isScript(position: vscode.Position) {
19 |         let text = this.document.getText();
20 |         if (!text.match(this.anyCfml)) {
21 |             return true;
22 |         }
23 | 
24 |         const range = new vscode.Range(new vscode.Position(0, 0), position);
25 |         text = this.document.getText(range);
26 |         let result = this.isBetweenTags(text, this.cfscriptBegin, this.cfscriptEnd);
27 |         if (!result) {
28 |             // check. it might be JavaScript tag.
29 |             result = this.isBetweenTags(text, this.scriptBegin, this.scriptEnd);
30 |         }
31 | 
32 |         return result;
33 |     }
34 | 
35 |     public isCFQuery(position: vscode.Position) {
36 |         const range = new vscode.Range(new vscode.Position(0, 0), position);
37 |         const text = this.document.getText(range);
38 |         const result = this.isBetweenTags(text, this.cfqueryBegin, this.cfqueryEnd);
39 |         return result;
40 |     }
41 | 
42 |     private isBetweenTags(text: string, start: RegExp, end: RegExp) {
43 |         let lastBegin = -1;
44 |         let lastEnd = -1;
45 |         let match: RegExpExecArray;
46 | 
47 |         match = start.exec(text);
48 |         while (match !== null) {
49 |             lastBegin = match.index;
50 |             match = start.exec(text);
51 |         }
52 | 
53 |         match = end.exec(text);
54 |         while (match !== null) {
55 |             lastEnd = match.index;
56 |             match = end.exec(text);
57 |         }
58 | 
59 |         return lastBegin > lastEnd;
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/vsc-extension-quickstart.md:
--------------------------------------------------------------------------------
 1 | # Welcome to your VS Code Extension
 2 | 
 3 | ## What's in the folder
 4 | * This folder contains all of the files necessary for your extension.
 5 | * `package.json` - this is the manifest file in which you declare your extension and command.
 6 | The sample plugin registers a command and defines its title and command name. With this information
 7 | VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
 8 | * `src/extension.ts` - this is the main file where you will provide the implementation of your command.
 9 | The file exports one function, `activate`, which is called the very first time your extension is
10 | activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
11 | We pass the function containing the implementation of the command as the second parameter to
12 | `registerCommand`.
13 | 
14 | ## Get up and running straight away
15 | * Press `F5` to open a new window with your extension loaded.
16 | * Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
17 | * Set breakpoints in your code inside `src/extension.ts` to debug your extension.
18 | * Find output from your extension in the debug console.
19 | 
20 | ## Make changes
21 | * You can relaunch the extension from the debug toolbar after changing code in `src/extension.ts`.
22 | * You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
23 | 
24 | ## Explore the API
25 | * You can open the full set of our API when you open the file `node_modules/vscode/vscode.d.ts`.
26 | 
27 | ## Run tests
28 | * Open the debug viewlet (`Ctrl+Shift+D` or `Cmd+Shift+D` on Mac) and from the launch configuration dropdown pick `Launch Tests`.
29 | * Press `F5` to run the tests in a new window with your extension loaded.
30 | * See the output of the test result in the debug console.
31 | * Make changes to `test/extension.test.ts` or create new test files inside the `test` folder.
32 |     * By convention, the test runner will only consider files matching the name pattern `**.test.ts`.
33 |     * You can create folders inside the `test` folder to structure your tests any way you want.
34 | 


--------------------------------------------------------------------------------
/src/test/ScriptContext.test.ts:
--------------------------------------------------------------------------------
 1 | import * as assert from "assert";
 2 | import * as path from "path";
 3 | import * as vscode from "vscode";
 4 | import { ScriptContext } from "../parser/ScriptContext";
 5 | 
 6 | const CFML_FILE = path.join(__dirname, "../../resources/test/ScriptContext/cfml_test.cfc");
 7 | const CFML_SCRIPT = path.join(__dirname, "../../resources/test/ScriptContext/cfscript_test.cfc");
 8 | 
 9 | suite("ScriptContext Tests", () => {
10 |     test("CFC with CFML", async () => {
11 |         const document = await vscode.workspace.openTextDocument(CFML_FILE);
12 |         const context = new ScriptContext(document);
13 |         const position = new vscode.Position(24, 11);
14 |         const isCFQuery = context.isCFQuery(position);
15 |         const isCFScript = context.isScript(position);
16 |         assert.strictEqual(isCFQuery, false);
17 |         assert.strictEqual(isCFScript, false);
18 |     });
19 | 
20 |     test("CFC with CFScript", async () => {
21 |         const document = await vscode.workspace.openTextDocument(CFML_SCRIPT);
22 |         const context = new ScriptContext(document);
23 |         const position = new vscode.Position(11, 11);
24 |         const isCFQuery = context.isCFQuery(position);
25 |         const isCFScript = context.isScript(position);
26 |         assert.strictEqual(isCFQuery, false);
27 |         assert.strictEqual(isCFScript, true);
28 |     });
29 | 
30 |     test("CFScript in CFML", async () => {
31 |         const document = await vscode.workspace.openTextDocument(CFML_FILE);
32 |         const context = new ScriptContext(document);
33 |         const position = new vscode.Position(18, 18);
34 |         const isCFQuery = context.isCFQuery(position);
35 |         const isCFScript = context.isScript(position);
36 |         assert.strictEqual(isCFQuery, false);
37 |         assert.strictEqual(isCFScript, true);
38 |     });
39 | 
40 |     test("CFQuery in CFML", async () => {
41 |         const document = await vscode.workspace.openTextDocument(CFML_FILE);
42 |         const context = new ScriptContext(document);
43 |         const position = new vscode.Position(28, 21);
44 |         const isCFQuery = context.isCFQuery(position);
45 |         const isCFScript = context.isScript(position);
46 |         assert.strictEqual(isCFQuery, true);
47 |         assert.strictEqual(isCFScript, false);
48 |     });
49 | });
50 | 


--------------------------------------------------------------------------------
/src/editor/providers/CfmlSnippetsCompletionProvider.ts:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | import * as vscode from "vscode";
 3 | import { CfmlSnippetsDataSource, ICfmlSnippets, ISnippet } from "../../data/CfmlSnippetsDataSource";
 4 | 
 5 | export class CfmlSnippetsCompletionProvider implements vscode.CompletionItemProvider {
 6 |     private dataSource = new CfmlSnippetsDataSource();
 7 | 
 8 |     public provideCompletionItems(document: vscode.TextDocument,
 9 |                                   position: vscode.Position,
10 |                                   token: vscode.CancellationToken,
11 |                                   context: vscode.CompletionContext):
12 |                                   vscode.ProviderResult<vscode.CompletionItem[] | vscode.CompletionList> {
13 |         return new Promise<vscode.CompletionItem[]>((resolve, reject) => {
14 |             this.dataSource.getSnippets().then((cfml) => {
15 |                 const completions: vscode.CompletionItem[] = [];
16 |                 if (cfml === null) {
17 |                     resolve(completions);
18 |                 }
19 | 
20 |                 if (cfml.functions !== null) {
21 |                     for (const snippet of cfml.functions) {
22 |                         const item = this.snippet2CompletionItem(snippet);
23 |                         completions.push(item);
24 |                     }
25 |                 }
26 | 
27 |                 if (cfml.tags !== null) {
28 |                     for (const snippet of cfml.tags) {
29 |                         const item = this.snippet2CompletionItem(snippet, true, document, position);
30 |                         completions.push(item);
31 |                     }
32 |                 }
33 | 
34 |                 return resolve(completions);
35 |             });
36 |         });
37 |     }
38 | 
39 |     private snippet2CompletionItem(snippet: ISnippet,
40 |                                    isTag: boolean = false,
41 |                                    document?: vscode.TextDocument,
42 |                                    position?: vscode.Position) {
43 |         const prefix = snippet.prefix;
44 |         const item = new vscode.CompletionItem(prefix, vscode.CompletionItemKind.Snippet);
45 |         item.documentation = new vscode.MarkdownString(snippet.documentation);
46 | 
47 |         // https://github.com/ilich/vscode-coldfusion/issues/32
48 |         let isSnippetSet = false;
49 |         if (isTag) {
50 |             const currentWord = document.getWordRangeAtPosition(position);
51 |             if (currentWord && currentWord.start.character > 0) {
52 |                 const chBeforeRange = new vscode.Range(currentWord.start.line, currentWord.start.character - 1,
53 |                     currentWord.start.line, currentWord.start.character);
54 |                 const chBefore = document.getText(chBeforeRange);
55 |                 if (chBefore === "<") {
56 |                     item.insertText = new vscode.SnippetString(snippet.body.substr(1));
57 |                     isSnippetSet = true;
58 |                 }
59 |             }
60 |         }
61 | 
62 |         if (!isSnippetSet) {
63 |             item.insertText = new vscode.SnippetString(snippet.body);
64 |         }
65 | 
66 |         return item;
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "name": "coldfusion",
  3 |     "displayName": "coldfusion",
  4 |     "description": "CFML Language Support for Visual Studio Code",
  5 |     "version": "1.0.1",
  6 |     "publisher": "ilich8086",
  7 |     "homepage": "https://github.com/ilich/vscode-coldfusion",
  8 |     "icon": "icon.png",
  9 |     "repository": {
 10 |         "type": "git",
 11 |         "url": "https://github.com/ilich/vscode-coldfusion.git"
 12 |     },
 13 |     "bugs": {
 14 |         "url": "https://github.com/ilich/vscode-coldfusion/issues"
 15 |     },
 16 |     "engines": {
 17 |         "vscode": "^1.18.0"
 18 |     },
 19 |     "categories": [
 20 |         "Languages",
 21 |         "Snippets",
 22 |         "Themes"
 23 |     ],
 24 |     "keywords": [
 25 |         "CFML",
 26 |         "ColdFusion",
 27 |         "Lucee"
 28 |     ],
 29 |     "activationEvents": [
 30 |         "onLanguage:cfml",
 31 |         "workspaceContains:**/*.cfm",
 32 |         "workspaceContains:**/*.cfml",
 33 |         "workspaceContains:**/*.cfc"
 34 |     ],
 35 |     "main": "./out/cfmlMain",
 36 |     "contributes": {
 37 |         "commands": [
 38 |             {
 39 |                 "command": "cfml.toggleBlockComment",
 40 |                 "category": "CFML",
 41 |                 "title": "Toggle Block Comment"
 42 |             },
 43 |             {
 44 |                 "command": "cfml.toggleLineComment",
 45 |                 "category": "CFML",
 46 |                 "title": "Toggle Line Comment"
 47 |             }
 48 |         ],
 49 |         "keybindings": [
 50 |             {
 51 |                 "command": "cfml.toggleLineComment",
 52 |                 "key": "ctrl+/",
 53 |                 "mac": "cmd+/",
 54 |                 "when": "editorTextFocus && !editorReadonly && editorLangId == cfml"
 55 |             },
 56 |             {
 57 |                 "command": "cfml.toggleBlockComment",
 58 |                 "key": "shift+alt+a",
 59 |                 "mac": "shift+alt+a",
 60 |                 "when": "editorTextFocus && !editorReadonly && editorLangId == cfml"
 61 |             }
 62 |         ],
 63 |         "languages": [
 64 |             {
 65 |                 "id": "cfml",
 66 |                 "aliases": [
 67 |                     "CFML",
 68 |                     "cfml"
 69 |                 ],
 70 |                 "extensions": [
 71 |                     ".cfm",
 72 |                     ".cfml",
 73 |                     ".cfc"
 74 |                 ],
 75 |                 "configuration": "./cfml.configuration.json"
 76 |             }
 77 |         ],
 78 |         "grammars": [
 79 |             {
 80 |                 "language": "cfml",
 81 |                 "scopeName": "text.html.cfm",
 82 |                 "path": "./syntaxes/cfml.tmLanguage"
 83 |             }
 84 |         ],
 85 |         "themes": [
 86 |             {
 87 |                 "label": "CFML Light",
 88 |                 "uiTheme": "vs",
 89 |                 "path": "./themes/cfml_light.json"
 90 |             },
 91 |             {
 92 |                 "label": "CFML Dark",
 93 |                 "uiTheme": "vs-dark",
 94 |                 "path": "./themes/cfml_dark.json"
 95 |             }
 96 |         ],
 97 |         "configuration": {
 98 |             "title": "CFML Language Support for Visual Studio Code configuration",
 99 |             "properties": {
100 |                 "cfml.snippets.enabled": {
101 |                     "type": "boolean",
102 |                     "default": true,
103 |                     "description": "Enable CFML snippets"
104 |                 }
105 |             }
106 |         }
107 |     },
108 |     "scripts": {
109 |         "vscode:prepublish": "npm run compile",
110 |         "compile": "tsc -p ./",
111 |         "watch": "tsc -watch -p ./",
112 |         "postinstall": "node ./node_modules/vscode/bin/install",
113 |         "test": "npm run compile && node ./node_modules/vscode/bin/test",
114 |         "snippets": "grunt"
115 |     },
116 |     "devDependencies": {
117 |         "@types/mocha": "^2.2.42",
118 |         "@types/node": "^7.0.43",
119 |         "grunt": "^1.0.1",
120 |         "typescript": "^2.5.3",
121 |         "vscode": "^1.1.5"
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/data/CfmlSnippetsDataSource.ts:
--------------------------------------------------------------------------------
  1 | /* tslint:disable:max-line-length */
  2 | "use strict";
  3 | import * as fs from "fs";
  4 | import * as path from "path";
  5 | 
  6 | const TAG_SNIPPETS: ISnippet[] = [
  7 |     {
  8 |         prefix: "cfif/cfelse",
  9 |         body: "<cfif ${1:expression}>\n<cfelse>\n</cfif>",
 10 |         documentation: "Creates simple and compound conditional statements in CFML. Tests an expression, variable, function return value, or string. Used, optionally, with the cfelse and cfelseif tags.",
 11 |     },
 12 |     {
 13 |         prefix: "cfif/cfelseif/cfelse",
 14 |         body: "<cfif ${1:expression}>\n<cfelseif ${2:expression}>\n<cfelse>\n</cfif>",
 15 |         documentation: "Creates simple and compound conditional statements in CFML. Tests an expression, variable, function return value, or string. Used, optionally, with the cfelse and cfelseif tags.",
 16 |     },
 17 |     {
 18 |         prefix: "cfswitch",
 19 |         body: "<cfswitch ${1:expression}>\n<cfcase value=\"${2:value}\">\n</cfcase>\n</cfswitch>",
 20 |         documentation: "Evaluates a passed expression and passes control to the cfcase tag that matches the expression result. You can, optionally, code a cfdefaultcase tag, which receives control if there is no matching cfcase tag value.",
 21 |     },
 22 |     {
 23 |         prefix: "cfswitch/cfdefaultcase",
 24 |         body: "<cfswitch ${1:expression}>\n<cfcase value=\"${2:value}\">\n</cfcase>\n<cfdefaultcase>\n</cfdefaultcase>\n</cfswitch>",
 25 |         documentation: "Evaluates a passed expression and passes control to the cfcase tag that matches the expression result. You can, optionally, code a cfdefaultcase tag, which receives control if there is no matching cfcase tag value.",
 26 |     },
 27 |     {
 28 |         prefix: "cfset",
 29 |         body: "<cfset ${1:variable} = ${2:expression}>",
 30 |         documentation: "Sets a value in CFML. Used to create a variable, if it does not exist, and assign it a value. Also used to call functions.",
 31 |     },
 32 |     {
 33 |         prefix: "cftry/cfcatch",
 34 |         body: "<cftry>\n<cfcatch type=\"${1:exception}\">\n</cfcatch>\n</cftry>",
 35 |         documentation: "Used inside a cftry tag. Code in the cffinally block is processed after the main cftry code and, if an exception occurs, the cfcatch code. The cffinally block code always executes, whether or not there is an exception.",
 36 |     },
 37 |     {
 38 |         prefix: "cftry/cffinally",
 39 |         body: "<cftry>\n<cffinally>\n</cffinally>\n</cftry>",
 40 |         documentation: "Used inside a cftry tag. Code in the cffinally block is processed after the main cftry code and, if an exception occurs, the cfcatch code. The cffinally block code always executes, whether or not there is an exception.",
 41 |     },
 42 |     {
 43 |         prefix: "cftry/cfcatch/cffinally",
 44 |         body: "<cftry>\n<cfcatch type=\"${1:exception}\">\n</cfcatch>\n<cffinally>\n</cffinally>\n</cftry>",
 45 |         documentation: "Used inside a cftry tag. Code in the cffinally block is processed after the main cftry code and, if an exception occurs, the cfcatch code. The cffinally block code always executes, whether or not there is an exception.",
 46 |     },
 47 |     {
 48 |         prefix: "cfloop: index loop",
 49 |         body: "<cfloop index=\"${1:index}\" from=\"${2:from}\" to=\"${3:to}\">\n</cfloop>",
 50 |         documentation: "An index loop repeats for a number of times that is determined by a numeric value. An index loop is also known as a FOR loop.",
 51 |     },
 52 |     {
 53 |         prefix: "cfloop: conditional loop",
 54 |         body: "<cfloop condition=\"${1:expression}\">\n</cfloop>",
 55 |         documentation: "A conditional loop iterates over a set of instructions as long as a condition is True. To use this type of loop correctly, the instructions must change the condition every time the loop iterates, until the condition is False. Conditional loops are known as WHILE loops, as in, \"loop WHILE this condition is true.\"",
 56 |     },
 57 |     {
 58 |         prefix: "cfloop: looping over a date or time range",
 59 |         body: "<cfloop index=\"${1:current value}\" from=\"${2:start time}\" to=\"${3:end time}\" step=\"#CreateTimeSpan(${4:days},0,0,0)#\">\n</cfloop>",
 60 |         documentation: "Loops over the date or time range specified by the from and to attributes. By default, the step is 1 day, but you can change the step by creating a timespan.",
 61 |     },
 62 |     {
 63 |         prefix: "cfloop: looping over a query",
 64 |         body: "<cfloop query=\"${1:query name}\">\n</cfloop>",
 65 |         documentation: "A loop over a query executes for each record in a query record set. The results are similar to those of the cfoutput tag. During each iteration, the columns of the current row are available for output. The cfloop tag loops over tags that cannot be used within a cfoutput tag.",
 66 |     },
 67 |     {
 68 |         prefix: "cfloop: struct",
 69 |         body: "<cfloop collection=\"#${1:struct}#\" item=\"${2:item}\">\n</cfloop>",
 70 |         documentation: "Looping over a struct.",
 71 |     },
 72 |     {
 73 |         prefix: "cfloop: array using item",
 74 |         body: "<cfloop array=\"#${1:array}#\" item=\"${2:item}\">\n</cfloop>",
 75 |         documentation: "Looping over an array.",
 76 |     },
 77 |     {
 78 |         prefix: "cfloop: array using index",
 79 |         body: "<cfloop array=\"#${1:array}#\" index=\"${2:index}\">\n</cfloop>",
 80 |         documentation: "Looping over an array.",
 81 |     },
 82 |     {
 83 |         prefix: "cfloop: list",
 84 |         body: "<cfloop list=\"#${1:list}#\" item=\"${2:item}\">\n</cfloop>",
 85 |         documentation: "Looping over a list.",
 86 |     },
 87 |     {
 88 |         prefix: "cfloop: file",
 89 |         body: "<cfloop file=\"#${1:file}#\" item=\"${2:item}\">\n</cfloop>",
 90 |         documentation: "Looping over a file.",
 91 |     },
 92 | ];
 93 | 
 94 | export interface ISnippet {
 95 |     prefix: string;
 96 |     body: string;
 97 |     documentation: string;
 98 | }
 99 | 
100 | export interface ICfmlSnippets {
101 |     tags: ISnippet[];
102 |     functions: ISnippet[];
103 | }
104 | 
105 | export class CfmlSnippetsDataSource {
106 |     public getSnippets(): Promise<ICfmlSnippets> {
107 |         return new Promise<ICfmlSnippets>((resolve, reject) => {
108 |             const result: ICfmlSnippets = {
109 |                 tags: null,
110 |                 functions: null,
111 |             };
112 | 
113 |             const functionsFile = path.join(__dirname, "../../resources/snippets/functions.json");
114 |             const tagsFile = path.join(__dirname, "../../resources/snippets/tags.json");
115 |             fs.readFile(functionsFile, "utf8", (err, data) => {
116 |                 if (err) {
117 |                     return resolve(result);
118 |                 }
119 | 
120 |                 result.functions = JSON.parse(data);
121 |                 // tslint:disable-next-line:no-shadowed-variable
122 |                 fs.readFile(tagsFile, "utf8", (err, data) => {
123 |                     if (err) {
124 |                         return resolve(result);
125 |                     }
126 | 
127 |                     result.tags = JSON.parse(data);
128 |                     result.tags = result.tags.concat(TAG_SNIPPETS);
129 |                     return resolve(result);
130 |                 });
131 |             });
132 |         });
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
  1 | let fs = require('fs');
  2 | let path = require('path');
  3 | 
  4 | module.exports = function(grunt) {
  5 | 
  6 |     function parseCfDocs(repo) {
  7 |         return new Promise(function (resolve, reject) {
  8 |             let docs = path.join(repo, 'data/en/');
  9 |             if (!fs.existsSync(docs)) {
 10 |                 reject(`CFDocs repository is not found at ${docs}. Git repository: https://github.com/foundeo/cfdocs/.`);
 11 |             }
 12 |             else {
 13 |                 files = fs.readdirSync(docs);
 14 |                 let result = {
 15 |                     tags: [],
 16 |                     functions: []
 17 |                 };
 18 | 
 19 |                 for (let file of files) {
 20 |                     if (path.extname(file) !== '.json') {
 21 |                         continue;
 22 |                     }
 23 | 
 24 |                     console.log(`Parsing ${file}`);
 25 |                     let filename = path.join(docs, file);
 26 |                     let content = fs.readFileSync(filename, 'utf8');
 27 |                     let doc = JSON.parse(content);
 28 |                     if (doc.type === 'tag') {
 29 |                         result.tags.push(doc);
 30 |                     }
 31 |                     else if (doc.type === 'function') {
 32 |                         result.functions.push(doc);
 33 |                     }
 34 |                 }
 35 | 
 36 |                 resolve(result);
 37 |             }
 38 |         });
 39 |     }
 40 |     
 41 |     grunt.initConfig({
 42 |         pkg: grunt.file.readJSON('package.json')
 43 |     });
 44 | 
 45 |     let cfdocs = null;
 46 |     grunt.registerTask('parse-cfdocs', function() {
 47 |         if (cfdocs !== null) {
 48 |             // parse the documentation just once for all tasks
 49 |             return;
 50 |         }
 51 | 
 52 |         var done = this.async();
 53 |         parseCfDocs('../cfdocs')
 54 |             .then(function (docs) {
 55 |                 cfdocs = docs;
 56 |                 done();
 57 |             })
 58 |             .catch(function (error) {
 59 |                 grunt.fatal(error);
 60 |             });
 61 |     });
 62 | 
 63 |     grunt.registerTask('build-snippets', function() {
 64 |         function createFunctionSnippet(item) {
 65 |             let snippet = {
 66 |                 prefix: item.name
 67 |             };
 68 | 
 69 |             let code = `${item.name}(`;
 70 |             let doc = `${item.description}\n\n**USAGE:**\n*${item.returns} ${item.name}(`;
 71 |             let docParams = [];
 72 |             let codeCounter = 1;
 73 | 
 74 |             for (let i = 0; item.params && i < item.params.length; i++) {
 75 |                 let param = item.params[i];
 76 |                 
 77 |                 if (param.required) {
 78 |                     if (i > 0) {
 79 |                         doc += ', ';
 80 |                         code += ', ';
 81 |                     }
 82 | 
 83 |                     doc += param.name;
 84 |                     
 85 |                     if (param.values && param.values.length > 0) {
 86 |                         let values = param.values.join(',');
 87 |                         code += `\${${codeCounter}|${values}|}`;
 88 |                     }
 89 |                     else {
 90 |                         code += `\${${codeCounter}:${param.name}}`;
 91 |                     }
 92 |                     
 93 |                     codeCounter++;
 94 |                 }
 95 |                 else {
 96 |                     doc += ' [';
 97 |                     if (i > 0) {
 98 |                         doc += ', ';
 99 |                     }
100 |                     
101 |                     doc += `${param.name}]`;
102 |                 }
103 | 
104 |                 let paramHelp = `*${param.name} (${param.type})*`;
105 |                 if (param.description && param.description.length > 0) {
106 |                     paramHelp += ` - ${param.description}`;
107 |                 }
108 | 
109 |                 if (param.default) {
110 |                     paramHelp += `. **Default:** *${param.default}*.`;
111 |                 }
112 | 
113 |                 if (param.values && param.values.length > 0) {
114 |                     paramHelp += ' **Values:** *' + param.values.join(', ') + '*.';
115 |                 }
116 | 
117 |                 docParams.push(paramHelp + '\n');
118 |             }
119 | 
120 |             code += ')';
121 |             doc += ')*';
122 |             doc += '\n\n**PARAMETERS:**\n\n';
123 |             doc += docParams.join('\n');
124 | 
125 |             snippet.body = code;
126 |             snippet.documentation = doc;
127 |             return snippet;
128 |         }
129 | 
130 |         const closedTags = [
131 |             'cfoutput', 
132 |             'cfquery', 
133 |             'cfif', 
134 |             'cfscript',
135 |             'cffunction',
136 |             'cfcomponent',
137 |             'cfmail',
138 |             'cfsavecontent'
139 |         ];
140 | 
141 |         const excludedTags = [
142 |             'cfswitch',
143 |             'cfloop',
144 |             'cftry',
145 |             'cfset'
146 |         ];
147 | 
148 |         function createTagSnippet(item) {
149 |             let snippet = {
150 |                 prefix: item.name
151 |             };
152 | 
153 |             let code = `<${item.name}`;
154 |             let doc = `${item.description}\n\n**USAGE:**\n*<${item.name}`;
155 |             let docParams = [];
156 |             let codeCounter = 1;
157 | 
158 |             for (let i = 0; item.params && i < item.params.length; i++) {
159 |                 let param = item.params[i];
160 |                 
161 |                 if (param.required) {
162 |                     doc += ' ';
163 |                     code += ' ';
164 | 
165 |                     doc += param.name + '=""';
166 |                     
167 |                     if (param.values && param.values.length > 0) {
168 |                         let values = param.values.join(',');
169 |                         code += ` ${param.name}="\${${codeCounter}|${values}|}"`;
170 |                     }
171 |                     else {
172 |                         code += ` ${param.name}="\${${codeCounter}:${param.name}}"`;
173 |                     }
174 |                     
175 |                     codeCounter++;
176 |                 }
177 |                 else {
178 |                     doc += ` [${param.name}=""]`;
179 |                 }
180 | 
181 |                 let paramHelp = `*${param.name} (${param.type})*`;
182 |                 if (param.description && param.description.length > 0) {
183 |                     paramHelp += ` - ${param.description}`;
184 |                 }
185 | 
186 |                 if (param.default) {
187 |                     paramHelp += `. **Default:** *${param.default}*.`;
188 |                 }
189 | 
190 |                 if (param.values && param.values.length > 0) {
191 |                     paramHelp += ' **Values:** *' + param.values.join(', ') + '*.';
192 |                 }
193 | 
194 |                 docParams.push(paramHelp + '\n');
195 |             }
196 | 
197 |             if (closedTags.indexOf(item.name) > -1) {
198 |                 code += `>\n</${item.name}>`;
199 |                 doc += `></${item.name}>*`;
200 |             } else {
201 |                 code += '>';
202 |                 doc += '>*';
203 |             }
204 |             
205 |             doc += '\n\n**PARAMETERS:**\n\n';
206 |             doc += docParams.join('\n');
207 | 
208 |             snippet.body = code;
209 |             snippet.documentation = doc;
210 |             return snippet;
211 |         }
212 | 
213 |         grunt.task.requires('parse-cfdocs');
214 | 
215 |         // prepare function snippets
216 | 
217 |         let snippets = [];
218 |         for (let func of cfdocs.functions) {
219 |             let snippet = createFunctionSnippet(func);
220 |             snippets.push(snippet);
221 |         }
222 | 
223 |         fs.writeFileSync('./build-snippets-functions.tmp', JSON.stringify(snippets), 'utf8');
224 | 
225 |         // prepare tag snippets
226 | 
227 |         snippets = [];
228 |         for (let tag of cfdocs.tags) {
229 |             if (excludedTags.indexOf(tag.name) > -1) {
230 |                 continue;
231 |             }
232 |             
233 |             let snippet = createTagSnippet(tag);
234 |             snippets.push(snippet);
235 |         }
236 | 
237 |         fs.writeFileSync('./build-snippets-tags.tmp', JSON.stringify(snippets), 'utf8');
238 |     });
239 | 
240 |     grunt.registerTask('get-tags', function() {
241 |         // create regular expression to parse CFML tags
242 | 
243 |         grunt.task.requires('parse-cfdocs');
244 |         let regexp = cfdocs.tags.map(function (doc) {
245 |             return doc.name;
246 |         }).join('|');
247 | 
248 |         console.log(regexp);
249 |         fs.writeFileSync('./get-tags.tmp', regexp, 'utf8');
250 |     });
251 | 
252 |     grunt.registerTask('default', ['parse-cfdocs', 'build-snippets']);
253 | 
254 | };


--------------------------------------------------------------------------------
/themes/cfml_dark.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"$schema": "vscode://schemas/color-theme",
  3 | 	"name": "CFML Dark",
  4 | 	"colors": {
  5 | 		"editor.background": "#1E1E1E",
  6 | 		"editor.foreground": "#D4D4D4",
  7 | 		"editor.inactiveSelectionBackground": "#3A3D41",
  8 | 		"editorIndentGuide.background": "#404040",
  9 | 		"editor.selectionHighlightBackground": "#ADD6FF26",
 10 | 		"list.dropBackground": "#383B3D",
 11 | 		"activityBarBadge.background": "#007ACC",
 12 | 		"sideBarTitle.foreground": "#BBBBBB"
 13 | 	},
 14 | 	"tokenColors": [
 15 | 		{
 16 | 			"settings": {
 17 | 				"foreground": "#D4D4D4",
 18 | 				"background": "#1E1E1E"
 19 | 			}
 20 | 		},
 21 | 		{
 22 | 			"scope": [
 23 | 				"meta.embedded",
 24 | 				"source.groovy.embedded"
 25 | 			],
 26 | 			"settings": {
 27 | 				"foreground": "#D4D4D4",
 28 | 				"background": "#1E1E1E"
 29 | 			}
 30 | 		},
 31 | 		{
 32 | 			"scope": "emphasis",
 33 | 			"settings": {
 34 | 				"fontStyle": "italic"
 35 | 			}
 36 | 		},
 37 | 		{
 38 | 			"scope": "strong",
 39 | 			"settings": {
 40 | 				"fontStyle": "bold"
 41 | 			}
 42 | 		},
 43 | 		{
 44 | 			"scope": "header",
 45 | 			"settings": {
 46 | 				"foreground": "#000080"
 47 | 			}
 48 | 		},
 49 | 		{
 50 | 			"scope": "comment",
 51 | 			"settings": {
 52 | 				"foreground": "#608b4e"
 53 | 			}
 54 | 		},
 55 | 		{
 56 | 			"scope": "constant.language",
 57 | 			"settings": {
 58 | 				"foreground": "#569cd6"
 59 | 			}
 60 | 		},
 61 | 		{
 62 | 			"scope": [
 63 | 				"constant.numeric"
 64 | 			],
 65 | 			"settings": {
 66 | 				"foreground": "#b5cea8"
 67 | 			}
 68 | 		},
 69 | 		{
 70 | 			"scope": "constant.regexp",
 71 | 			"settings": {
 72 | 				"foreground": "#646695"
 73 | 			}
 74 | 		},
 75 | 		{
 76 | 			"scope": [
 77 |                 "entity.name.tag",
 78 |                 "source.js.embedded.html"
 79 |             ],
 80 | 			"settings": {
 81 | 				"foreground": "#569cd6"
 82 | 			}
 83 | 		},
 84 | 		{
 85 | 			"scope": "entity.name.tag.css",
 86 | 			"settings": {
 87 | 				"foreground": "#d7ba7d"
 88 | 			}
 89 | 		},
 90 | 		{
 91 | 			"scope": "entity.other.attribute-name",
 92 | 			"settings": {
 93 | 				"foreground": "#9cdcfe"
 94 | 			}
 95 | 		},
 96 | 		{
 97 | 			"scope": [
 98 | 				"entity.other.attribute-name.class.css",
 99 | 				"entity.other.attribute-name.class.mixin.css",
100 | 				"entity.other.attribute-name.id.css",
101 | 				"entity.other.attribute-name.parent-selector.css",
102 | 				"entity.other.attribute-name.pseudo-class.css",
103 | 				"entity.other.attribute-name.pseudo-element.css",
104 | 				"source.css.less entity.other.attribute-name.id",
105 | 				"entity.other.attribute-name.attribute.scss",
106 | 				"entity.other.attribute-name.scss"
107 | 			],
108 | 			"settings": {
109 | 				"foreground": "#d7ba7d"
110 | 			}
111 | 		},
112 | 		{
113 | 			"scope": "invalid",
114 | 			"settings": {
115 | 				"foreground": "#f44747"
116 | 			}
117 | 		},
118 | 		{
119 | 			"scope": "markup.underline",
120 | 			"settings": {
121 | 				"fontStyle": "underline"
122 | 			}
123 | 		},
124 | 		{
125 | 			"scope": "markup.bold",
126 | 			"settings": {
127 | 				"fontStyle": "bold",
128 | 				"foreground": "#569cd6"
129 | 			}
130 | 		},
131 | 		{
132 | 			"scope": "markup.heading",
133 | 			"settings": {
134 | 				"fontStyle": "bold",
135 | 				"foreground": "#569cd6"
136 | 			}
137 | 		},
138 | 		{
139 | 			"scope": "markup.italic",
140 | 			"settings": {
141 | 				"fontStyle": "italic"
142 | 			}
143 | 		},
144 | 		{
145 | 			"scope": "markup.inserted",
146 | 			"settings": {
147 | 				"foreground": "#b5cea8"
148 | 			}
149 | 		},
150 | 		{
151 | 			"scope": "markup.deleted",
152 | 			"settings": {
153 | 				"foreground": "#ce9178"
154 | 			}
155 | 		},
156 | 		{
157 | 			"scope": "markup.changed",
158 | 			"settings": {
159 | 				"foreground": "#569cd6"
160 | 			}
161 | 		},
162 | 		{
163 | 			"scope": "beginning.punctuation.definition.quote.markdown",
164 | 			"settings": {
165 | 				"foreground": "#608b4e"
166 | 			}
167 | 		},
168 | 		{
169 | 			"scope": "beginning.punctuation.definition.list.markdown",
170 | 			"settings": {
171 | 				"foreground": "#6796e6"
172 | 			}
173 | 		},
174 | 		{
175 | 			"scope": "markup.inline.raw",
176 | 			"settings": {
177 | 				"foreground": "#ce9178"
178 | 			}
179 | 		},
180 | 		{
181 | 			"scope": "meta.selector",
182 | 			"settings": {
183 | 				"foreground": "#d7ba7d"
184 | 			}
185 | 		},
186 | 		{
187 | 			"name": "brackets of XML/HTML tags",
188 | 			"scope": "punctuation.definition.tag",
189 | 			"settings": {
190 | 				"foreground": "#808080"
191 | 			}
192 | 		},
193 | 		{
194 | 			"scope": "meta.preprocessor",
195 | 			"settings": {
196 | 				"foreground": "#569cd6"
197 | 			}
198 | 		},
199 | 		{
200 | 			"scope": "meta.preprocessor.string",
201 | 			"settings": {
202 | 				"foreground": "#ce9178"
203 | 			}
204 | 		},
205 | 		{
206 | 			"scope": "meta.preprocessor.numeric",
207 | 			"settings": {
208 | 				"foreground": "#b5cea8"
209 | 			}
210 | 		},
211 | 		{
212 | 			"scope": "meta.structure.dictionary.key.python",
213 | 			"settings": {
214 | 				"foreground": "#9cdcfe"
215 | 			}
216 | 		},
217 | 		{
218 | 			"scope": "meta.diff.header",
219 | 			"settings": {
220 | 				"foreground": "#569cd6"
221 | 			}
222 | 		},
223 | 		{
224 | 			"scope": "storage",
225 | 			"settings": {
226 | 				"foreground": "#569cd6"
227 | 			}
228 | 		},
229 | 		{
230 | 			"scope": "storage.type",
231 | 			"settings": {
232 | 				"foreground": "#569cd6"
233 | 			}
234 | 		},
235 | 		{
236 | 			"scope": "storage.modifier",
237 | 			"settings": {
238 | 				"foreground": "#569cd6"
239 | 			}
240 | 		},
241 | 		{
242 | 			"scope": "string",
243 | 			"settings": {
244 | 				"foreground": "#ce9178"
245 | 			}
246 | 		},
247 | 		{
248 | 			"scope": "string.tag",
249 | 			"settings": {
250 | 				"foreground": "#ce9178"
251 | 			}
252 | 		},
253 | 		{
254 | 			"scope": "string.value",
255 | 			"settings": {
256 | 				"foreground": "#ce9178"
257 | 			}
258 | 		},
259 | 		{
260 | 			"scope": "string.regexp",
261 | 			"settings": {
262 | 				"foreground": "#d16969"
263 | 			}
264 | 		},
265 | 		{
266 | 			"name": "String interpolation",
267 | 			"scope": [
268 | 				"punctuation.definition.template-expression.begin",
269 | 				"punctuation.definition.template-expression.end",
270 | 				"punctuation.section.embedded"
271 | 			],
272 | 			"settings": {
273 | 				"foreground": "#569cd6"
274 | 			}
275 | 		},
276 | 		{
277 | 			"name": "Reset JavaScript string interpolation expression",
278 | 			"scope": [
279 | 				"meta.template.expression"
280 | 			],
281 | 			"settings": {
282 | 				"foreground": "#d4d4d4"
283 | 			}
284 | 		},
285 | 		{
286 | 			"scope": [
287 | 				"support.type.vendored.property-name",
288 | 				"support.type.property-name",
289 | 				"variable.css",
290 | 				"variable.scss",
291 | 				"variable.other.less",
292 | 				"source.coffee.embedded"
293 | 			],
294 | 			"settings": {
295 | 				"foreground": "#9cdcfe"
296 | 			}
297 | 		},
298 | 		{
299 | 			"scope": "keyword",
300 | 			"settings": {
301 | 				"foreground": "#569cd6"
302 | 			}
303 | 		},
304 | 		{
305 | 			"scope": "keyword.control",
306 | 			"settings": {
307 | 				"foreground": "#569cd6"
308 | 			}
309 | 		},
310 | 		{
311 | 			"scope": "keyword.operator",
312 | 			"settings": {
313 | 				"foreground": "#d4d4d4"
314 | 			}
315 | 		},
316 | 		{
317 | 			"scope": [
318 | 				"keyword.operator.new",
319 | 				"keyword.operator.expression",
320 | 				"keyword.operator.cast",
321 | 				"keyword.operator.sizeof",
322 | 				"keyword.operator.logical.python"
323 | 			],
324 | 			"settings": {
325 | 				"foreground": "#569cd6"
326 | 			}
327 | 		},
328 | 		{
329 | 			"scope": "keyword.other.unit",
330 | 			"settings": {
331 | 				"foreground": "#b5cea8"
332 | 			}
333 | 		},
334 | 		{
335 | 			"scope": [
336 | 				"punctuation.section.embedded.begin.php",
337 | 				"punctuation.section.embedded.end.php"
338 | 			],
339 | 			"settings": {
340 | 				"foreground": "#569cd6"
341 | 			}
342 | 		},
343 | 		{
344 | 			"scope": "support.function.git-rebase",
345 | 			"settings": {
346 | 				"foreground": "#9cdcfe"
347 | 			}
348 | 		},
349 | 		{
350 | 			"scope": "constant.sha.git-rebase",
351 | 			"settings": {
352 | 				"foreground": "#b5cea8"
353 | 			}
354 | 		},
355 | 		{
356 | 			"name": "coloring of the Java import and package identifiers",
357 | 			"scope": [
358 | 				"storage.modifier.import.java",
359 | 				"variable.language.wildcard.java",
360 | 				"storage.modifier.package.java"
361 | 			],
362 | 			"settings": {
363 | 				"foreground": "#d4d4d4"
364 | 			}
365 | 		},
366 | 		{
367 | 			"name": "this.self",
368 | 			"scope": "variable.language",
369 | 			"settings": {
370 | 				"foreground": "#569cd6"
371 | 			}
372 |         },
373 |         {
374 | 			"name": "Function declarations",
375 | 			"scope": [
376 | 				"entity.name.function",
377 | 				"support.function",
378 | 				"support.constant.handlebars"
379 | 			],
380 | 			"settings": {
381 | 				"foreground": "#DCDCAA"
382 | 			}
383 | 		},
384 | 		{
385 | 			"name": "Types declaration and references",
386 | 			"scope": [
387 | 				"meta.return-type",
388 | 				"support.class",
389 | 				"support.type",
390 | 				"entity.name.type",
391 | 				"entity.name.class",
392 | 				"storage.type.cs",
393 | 				"storage.type.generic.cs",
394 | 				"storage.type.modifier.cs",
395 | 				"storage.type.variable.cs",
396 | 				"storage.type.annotation.java",
397 | 				"storage.type.generic.java",
398 | 				"storage.type.java",
399 | 				"storage.type.object.array.java",
400 | 				"storage.type.primitive.array.java",
401 | 				"storage.type.primitive.java",
402 | 				"storage.type.token.java",
403 | 				"storage.type.groovy",
404 | 				"storage.type.annotation.groovy",
405 | 				"storage.type.parameters.groovy",
406 | 				"storage.type.generic.groovy",
407 | 				"storage.type.object.array.groovy",
408 | 				"storage.type.primitive.array.groovy",
409 | 				"storage.type.primitive.groovy"
410 | 			],
411 | 			"settings": {
412 | 				"foreground": "#4EC9B0"
413 | 			}
414 | 		},
415 | 		{
416 | 			"name": "Types declaration and references, TS grammar specific",
417 | 			"scope": [
418 | 				"meta.type.cast.expr",
419 | 				"meta.type.new.expr",
420 | 				"support.constant.math",
421 | 				"support.constant.dom",
422 | 				"support.constant.json",
423 | 				"entity.other.inherited-class"
424 | 			],
425 | 			"settings": {
426 | 				"foreground": "#4EC9B0"
427 | 			}
428 | 		},
429 | 		{
430 | 			"name": "Control flow keywords",
431 | 			"scope": "keyword.control",
432 | 			"settings": {
433 | 				"foreground": "#C586C0"
434 | 			}
435 | 		},
436 | 		{
437 | 			"name": "Variable and parameter name",
438 | 			"scope": [
439 | 				"variable",
440 | 				"meta.definition.variable.name",
441 | 				"support.variable"
442 | 			],
443 | 			"settings": {
444 | 				"foreground": "#9CDCFE"
445 | 			}
446 | 		},
447 | 		{
448 | 			"name": "Object keys, TS grammar specific",
449 | 			"scope": [
450 | 				"meta.object-literal.key",
451 | 				"meta.object-literal.key entity.name.function"
452 | 			],
453 | 			"settings": {
454 | 				"foreground": "#9CDCFE"
455 | 			}
456 | 		},
457 | 		{
458 | 			"name": "CSS property value",
459 | 			"scope": [
460 | 				"support.constant.property-value",
461 | 				"support.constant.font-name",
462 | 				"support.constant.media-type",
463 | 				"support.constant.media",
464 | 				"constant.other.color.rgb-value",
465 | 				"constant.other.rgb-value",
466 | 				"support.constant.color"
467 | 			],
468 | 			"settings": {
469 | 				"foreground": "#CE9178"
470 | 			}
471 | 		},
472 | 		{
473 | 			"name": "Regular expression groups",
474 | 			"scope": [
475 | 				"punctuation.definition.group.regexp",
476 | 				"punctuation.definition.group.assertion.regexp",
477 | 				"punctuation.definition.character-class.regexp",
478 | 				"punctuation.character.set.begin.regexp",
479 | 				"punctuation.character.set.end.regexp",
480 | 				"keyword.operator.negation.regexp",
481 | 				"support.other.parenthesis.regexp"
482 | 			],
483 | 			"settings": {
484 | 				"foreground": "#CE9178"
485 | 			}
486 | 		},
487 | 		{
488 | 			"scope": [
489 | 				"constant.character.character-class.regexp",
490 | 				"constant.other.character-class.set.regexp",
491 | 				"constant.other.character-class.regexp",
492 | 				"constant.character.set.regexp"
493 | 			],
494 | 			"settings": {
495 | 				"foreground": "#d16969"
496 | 			}
497 | 		},
498 | 		{
499 | 			"scope": [
500 | 				"keyword.operator.or.regexp",
501 | 				"keyword.control.anchor.regexp"
502 | 			],
503 | 			"settings": {
504 | 				"foreground": "#DCDCAA"
505 | 			}
506 | 		},
507 | 		{
508 | 			"scope": "keyword.operator.quantifier.regexp",
509 | 			"settings": {
510 | 				"foreground": "#d7ba7d"
511 | 			}
512 | 		},
513 | 		{
514 | 			"scope": "constant.character",
515 | 			"settings": {
516 | 				"foreground": "#569cd6"
517 | 			}
518 | 		},
519 | 		{
520 | 			"scope": "constant.character.escape",
521 | 			"settings": {
522 | 				"foreground": "#d7ba7d"
523 | 			}
524 |         },
525 |         {
526 | 			"scope": [
527 |                 "entity.name.tag.cfml",
528 |                 "entity.name.tag.custom.cfml",
529 |                 "keyword.operator.decision.cfml"
530 |             ],
531 | 			"settings": {
532 | 				"foreground": "#d7ba7d"
533 | 			}
534 | 		}
535 | 	]
536 | }


--------------------------------------------------------------------------------
/themes/cfml_light.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"name": "CFML Light",
  3 | 	"type": "light",
  4 | 	"colors": {
  5 | 		"editor.background": "#FFFFFF",
  6 | 		"editor.foreground": "#000000",
  7 | 		"editor.inactiveSelectionBackground": "#E5EBF1",
  8 | 		"editorIndentGuide.background": "#D3D3D3",
  9 | 		"editor.selectionHighlightBackground": "#ADD6FF4D",
 10 | 		"editorSuggestWidget.background": "#F3F3F3",
 11 | 		"activityBarBadge.background": "#007ACC",
 12 | 		"sideBarTitle.foreground": "#6F6F6F"
 13 | 	},
 14 | 	"tokenColors": [
 15 | 		{
 16 | 			"scope": ["meta.embedded", "source.groovy.embedded"],
 17 | 			"settings": {
 18 | 				"foreground": "#000000ff",
 19 | 				"background":"#ffffffff"
 20 | 			}
 21 | 		},
 22 | 		{
 23 | 			"scope": "emphasis",
 24 | 			"settings": {
 25 | 				"fontStyle": "italic"
 26 | 			}
 27 | 		},
 28 | 		{
 29 | 			"scope": "strong",
 30 | 			"settings": {
 31 | 				"fontStyle": "bold"
 32 | 			}
 33 | 		},
 34 | 		{
 35 | 			"scope": "meta.diff.header",
 36 | 			"settings": {
 37 | 				"foreground": "#000080"
 38 | 			}
 39 | 		},
 40 | 		{
 41 | 			"scope": "comment",
 42 | 			"settings": {
 43 | 				"foreground": "#008000"
 44 | 			}
 45 | 		},
 46 | 		{
 47 | 			"scope": "constant.language",
 48 | 			"settings": {
 49 | 				"foreground": "#0000ff"
 50 | 			}
 51 | 		},
 52 | 		{
 53 | 			"scope": [
 54 | 				"constant.numeric"
 55 | 			],
 56 | 			"settings": {
 57 | 				"foreground": "#09885a"
 58 | 			}
 59 | 		},
 60 | 		{
 61 | 			"scope": "constant.regexp",
 62 | 			"settings": {
 63 | 				"foreground": "#811f3f"
 64 | 			}
 65 | 		},
 66 | 		{
 67 | 			"name": "css tags in selectors, xml tags",
 68 | 			"scope": "entity.name.tag",
 69 | 			"settings": {
 70 | 				"foreground": "#800000"
 71 | 			}
 72 | 		},
 73 | 		{
 74 | 			"name": "embedded javascript (script tag)",
 75 | 			"scope": "source.js.embedded.html",
 76 | 			"settings": {
 77 | 				"foreground": "#800000"
 78 | 			}
 79 | 		},
 80 | 		{
 81 | 			"name": "cfml tags",
 82 | 			"scope": "entity.name.tag.cfml",
 83 | 			"settings": {
 84 | 				"foreground": "#0066CC"
 85 | 			}
 86 | 		},
 87 | 		{
 88 | 			"name": "cfml custom tags",
 89 | 			"scope": "entity.name.tag.custom.cfml",
 90 | 			"settings": {
 91 | 				"foreground": "#3300CC"
 92 | 			}
 93 | 		},
 94 | 		{
 95 | 			"name": "cfml operators",
 96 | 			"scope": "keyword.operator.decision.cfml",
 97 | 			"settings": {
 98 | 				"foreground": "#0066CC"
 99 | 			}
100 | 		},
101 | 		{
102 | 			"scope": "entity.name.selector",
103 | 			"settings": {
104 | 				"foreground": "#800000"
105 | 			}
106 | 		},
107 | 		{
108 | 			"scope": "entity.other.attribute-name",
109 | 			"settings": {
110 | 				"foreground": "#ff0000"
111 | 			}
112 | 		},
113 | 		{
114 | 			"scope": [
115 | 				"entity.other.attribute-name.class.css",
116 | 				"entity.other.attribute-name.class.mixin.css",
117 | 				"entity.other.attribute-name.id.css",
118 | 				"entity.other.attribute-name.parent-selector.css",
119 | 				"entity.other.attribute-name.pseudo-class.css",
120 | 				"entity.other.attribute-name.pseudo-element.css",
121 | 				"source.css.less entity.other.attribute-name.id",
122 | 				"entity.other.attribute-name.attribute.scss",
123 | 				"entity.other.attribute-name.scss"
124 | 			],
125 | 			"settings": {
126 | 				"foreground": "#800000"
127 | 			}
128 | 		},
129 | 		{
130 | 			"scope": "invalid",
131 | 			"settings": {
132 | 				"foreground": "#cd3131"
133 | 			}
134 | 		},
135 | 		{
136 | 			"scope": "markup.underline",
137 | 			"settings": {
138 | 				"fontStyle": "underline"
139 | 			}
140 | 		},
141 | 		{
142 | 			"scope": "markup.bold",
143 | 			"settings": {
144 | 				"fontStyle": "bold",
145 | 				"foreground": "#000080"
146 | 			}
147 | 		},
148 | 		{
149 | 			"scope": "markup.heading",
150 | 			"settings": {
151 | 				"fontStyle": "bold",
152 | 				"foreground": "#800000"
153 | 			}
154 | 		},
155 | 		{
156 | 			"scope": "markup.italic",
157 | 			"settings": {
158 | 				"fontStyle": "italic"
159 | 			}
160 | 		},
161 | 		{
162 | 			"scope": "markup.inserted",
163 | 			"settings": {
164 | 				"foreground": "#09885a"
165 | 			}
166 | 		},
167 | 		{
168 | 			"scope": "markup.deleted",
169 | 			"settings": {
170 | 				"foreground": "#a31515"
171 | 			}
172 | 		},
173 | 		{
174 | 			"scope": "markup.changed",
175 | 			"settings": {
176 | 				"foreground": "#0451a5"
177 | 			}
178 | 		},
179 | 		{
180 | 			"scope": [
181 | 				"beginning.punctuation.definition.quote.markdown",
182 | 				"beginning.punctuation.definition.list.markdown"
183 | 			],
184 | 			"settings": {
185 | 				"foreground": "#0451a5"
186 | 			}
187 | 		},
188 | 		{
189 | 			"scope": "markup.inline.raw",
190 | 			"settings": {
191 | 				"foreground": "#800000"
192 | 			}
193 | 		},
194 | 		{
195 | 			"scope": "meta.selector",
196 | 			"settings": {
197 | 				"foreground": "#800000"
198 | 			}
199 | 		},
200 | 		{
201 | 			"name": "brackets of XML/HTML tags",
202 | 			"scope": "punctuation.definition.tag",
203 | 			"settings": {
204 | 				"foreground": "#800000"
205 | 			}
206 | 		},
207 | 		{
208 | 			"scope": "meta.preprocessor",
209 | 			"settings": {
210 | 				"foreground": "#0000ff"
211 | 			}
212 | 		},
213 | 		{
214 | 			"scope": "meta.preprocessor.string",
215 | 			"settings": {
216 | 				"foreground": "#a31515"
217 | 			}
218 | 		},
219 | 		{
220 | 			"scope": "meta.preprocessor.numeric",
221 | 			"settings": {
222 | 				"foreground": "#09885a"
223 | 			}
224 | 		},
225 | 		{
226 | 			"scope": "meta.structure.dictionary.key.python",
227 | 			"settings": {
228 | 				"foreground": "#0451a5"
229 | 			}
230 | 		},
231 | 		{
232 | 			"scope": "storage",
233 | 			"settings": {
234 | 				"foreground": "#0000ff"
235 | 			}
236 | 		},
237 | 		{
238 | 			"scope": "storage.type",
239 | 			"settings": {
240 | 				"foreground": "#0000ff"
241 | 			}
242 | 		},
243 | 		{
244 | 			"scope": "storage.modifier",
245 | 			"settings": {
246 | 				"foreground": "#0000ff"
247 | 			}
248 | 		},
249 | 		{
250 | 			"scope": "string",
251 | 			"settings": {
252 | 				"foreground": "#a31515"
253 | 			}
254 | 		},
255 | 		{
256 | 			"scope": [
257 | 				"string.comment.buffered.block.jade",
258 | 				"string.quoted.jade",
259 | 				"string.interpolated.jade",
260 | 				"string.unquoted.plain.in.yaml",
261 | 				"string.unquoted.plain.out.yaml",
262 | 				"string.unquoted.block.yaml",
263 | 				"string.quoted.single.yaml",
264 | 				"string.quoted.double.xml",
265 | 				"string.quoted.single.xml",
266 | 				"string.unquoted.cdata.xml",
267 | 				"string.quoted.double.html",
268 | 				"string.quoted.single.html",
269 | 				"string.unquoted.html",
270 | 				"string.quoted.single.handlebars",
271 | 				"string.quoted.double.handlebars"
272 | 			],
273 | 			"settings": {
274 | 				"foreground": "#0000ff"
275 | 			}
276 | 		},
277 | 		{
278 | 			"scope": "string.regexp",
279 | 			"settings": {
280 | 				"foreground": "#811f3f"
281 | 			}
282 | 		},
283 | 		{
284 | 			"name": "String interpolation",
285 | 			"scope": [
286 | 				"punctuation.definition.template-expression.begin",
287 | 				"punctuation.definition.template-expression.end",
288 | 				"punctuation.section.embedded"
289 | 			],
290 | 			"settings": {
291 | 				"foreground": "#0000ff"
292 | 			}
293 | 		},
294 | 		{
295 | 			"name": "Reset JavaScript string interpolation expression",
296 | 			"scope": [
297 | 				"meta.template.expression"
298 | 			],
299 | 			"settings": {
300 | 				"foreground": "#000000"
301 | 			}
302 | 		},
303 | 		{
304 | 			"scope": [
305 | 				"support.constant.property-value",
306 | 				"support.constant.font-name",
307 | 				"support.constant.media-type",
308 | 				"support.constant.media",
309 | 				"constant.other.color.rgb-value",
310 | 				"constant.other.rgb-value",
311 | 				"support.constant.color"
312 | 			],
313 | 			"settings": {
314 | 				"foreground": "#0451a5"
315 | 			}
316 | 		},
317 | 		{
318 | 			"scope": [
319 | 				"support.type.vendored.property-name",
320 | 				"support.type.property-name",
321 | 				"variable.css",
322 | 				"variable.scss",
323 | 				"variable.other.less",
324 | 				"source.coffee.embedded"
325 | 			],
326 | 			"settings": {
327 | 				"foreground": "#ff0000"
328 | 			}
329 | 		},
330 | 		{
331 | 			"scope": "support.type.property-name.json",
332 | 			"settings": {
333 | 				"foreground": "#0451a5"
334 | 			}
335 | 		},
336 | 		{
337 | 			"scope": "keyword",
338 | 			"settings": {
339 | 				"foreground": "#0000ff"
340 | 			}
341 | 		},
342 | 		{
343 | 			"scope": "keyword.control",
344 | 			"settings": {
345 | 				"foreground": "#0000ff"
346 | 			}
347 | 		},
348 | 		{
349 | 			"scope": "keyword.operator",
350 | 			"settings": {
351 | 				"foreground": "#000000"
352 | 			}
353 | 		},
354 | 		{
355 | 			"scope": [
356 | 				"keyword.operator.new",
357 | 				"keyword.operator.expression",
358 | 				"keyword.operator.cast",
359 | 				"keyword.operator.sizeof",
360 | 				"keyword.operator.logical.python"
361 | 			],
362 | 			"settings": {
363 | 				"foreground": "#0000ff"
364 | 			}
365 | 		},
366 | 		{
367 | 			"scope": "keyword.other.unit",
368 | 			"settings": {
369 | 				"foreground": "#09885a"
370 | 			}
371 | 		},
372 | 		{
373 | 			"scope": [
374 | 				"punctuation.section.embedded.begin.php",
375 | 				"punctuation.section.embedded.end.php"
376 | 			],
377 | 			"settings": {
378 | 				"foreground": "#800000"
379 | 			}
380 | 		},
381 | 		{
382 | 			"scope": "support.function.git-rebase",
383 | 			"settings": {
384 | 				"foreground": "#0451a5"
385 | 			}
386 | 		},
387 | 		{
388 | 			"scope": "constant.sha.git-rebase",
389 | 			"settings": {
390 | 				"foreground": "#09885a"
391 | 			}
392 | 		},
393 | 		{
394 | 			"name": "coloring of the Java import and package identifiers",
395 | 			"scope": [
396 | 				"storage.modifier.import.java",
397 | 				"variable.language.wildcard.java",
398 | 				"storage.modifier.package.java"
399 | 			],
400 | 			"settings": {
401 | 				"foreground": "#000000"
402 | 			}
403 | 		},
404 | 		{
405 | 			"name": "this.self",
406 | 			"scope": "variable.language",
407 | 			"settings": {
408 | 				"foreground": "#0000ff"
409 | 			}
410 | 		},
411 | 		{
412 | 			"name": "Function declarations",
413 | 			"scope": [
414 | 				"entity.name.function",
415 | 				"support.function",
416 | 				"support.constant.handlebars"
417 | 			],
418 | 			"settings": {
419 | 				"foreground": "#795E26"
420 | 			}
421 | 		},
422 | 		{
423 | 			"name": "Types declaration and references",
424 | 			"scope": [
425 | 				"meta.return-type",
426 | 				"support.class",
427 | 				"support.type",
428 | 				"entity.name.type",
429 | 				"entity.name.class",
430 | 				"storage.type.cs",
431 | 				"storage.type.generic.cs",
432 | 				"storage.type.modifier.cs",
433 | 				"storage.type.variable.cs",
434 | 				"storage.type.annotation.java",
435 | 				"storage.type.generic.java",
436 | 				"storage.type.java",
437 | 				"storage.type.object.array.java",
438 | 				"storage.type.primitive.array.java",
439 | 				"storage.type.primitive.java",
440 | 				"storage.type.token.java",
441 | 				"storage.type.groovy",
442 | 				"storage.type.annotation.groovy",
443 | 				"storage.type.parameters.groovy",
444 | 				"storage.type.generic.groovy",
445 | 				"storage.type.object.array.groovy",
446 | 				"storage.type.primitive.array.groovy",
447 | 				"storage.type.primitive.groovy"
448 | 			],
449 | 			"settings": {
450 | 				"foreground": "#267f99"
451 | 			}
452 | 		},
453 | 		{
454 | 			"name": "Types declaration and references, TS grammar specific",
455 | 			"scope": [
456 | 				"meta.type.cast.expr",
457 | 				"meta.type.new.expr",
458 | 				"support.constant.math",
459 | 				"support.constant.dom",
460 | 				"support.constant.json",
461 | 				"entity.other.inherited-class"
462 | 			],
463 | 			"settings": {
464 | 				"foreground": "#267f99"
465 | 			}
466 | 		},
467 | 		{
468 | 			"name": "Control flow keywords",
469 | 			"scope": "keyword.control",
470 | 			"settings": {
471 | 				"foreground": "#AF00DB"
472 | 			}
473 | 		},
474 | 		{
475 | 			"name": "Variable and parameter name",
476 | 			"scope": [
477 | 				"variable",
478 | 				"meta.definition.variable.name",
479 | 				"support.variable"
480 | 			],
481 | 			"settings": {
482 | 				"foreground": "#001080"
483 | 			}
484 | 		},
485 | 		{
486 | 			"name": "Object keys, TS grammar specific",
487 | 			"scope": [
488 | 				"meta.object-literal.key",
489 | 				"meta.object-literal.key entity.name.function"
490 | 			],
491 | 			"settings": {
492 | 				"foreground": "#001080"
493 | 			}
494 | 		},
495 | 		{
496 | 			"name": "CSS property value",
497 | 			"scope": [
498 | 				"support.constant.property-value",
499 | 				"support.constant.font-name",
500 | 				"support.constant.media-type",
501 | 				"support.constant.media",
502 | 				"constant.other.color.rgb-value",
503 | 				"constant.other.rgb-value",
504 | 				"support.constant.color"
505 | 			],
506 | 			"settings": {
507 | 				"foreground": "#0451a5"
508 | 			}
509 | 		},
510 | 		{
511 | 			"name": "Regular expression groups",
512 | 			"scope": [
513 | 				"punctuation.definition.group.regexp",
514 | 				"punctuation.definition.group.assertion.regexp",
515 | 				"punctuation.definition.character-class.regexp",
516 | 				"punctuation.character.set.begin.regexp",
517 | 				"punctuation.character.set.end.regexp",
518 | 				"keyword.operator.negation.regexp",
519 | 				"support.other.parenthesis.regexp"
520 | 			],
521 | 			"settings": {
522 | 				"foreground": "#d16969"
523 | 			}
524 | 		},
525 | 		{
526 | 			"scope": [
527 | 				"constant.character.character-class.regexp",
528 | 				"constant.other.character-class.set.regexp",
529 | 				"constant.other.character-class.regexp",
530 | 				"constant.character.set.regexp"
531 | 			],
532 | 			"settings": {
533 | 				"foreground": "#811f3f"
534 | 			}
535 | 		},
536 | 		{
537 | 			"scope": "keyword.operator.quantifier.regexp",
538 | 			"settings": {
539 | 				"foreground": "#000000"
540 | 			}
541 | 		},
542 | 		{
543 | 			"scope": [
544 | 				"keyword.operator.or.regexp",
545 | 				"keyword.control.anchor.regexp"
546 | 			],
547 | 			"settings": {
548 | 				"foreground": "#ff0000"
549 | 			}
550 | 		},
551 | 		{
552 | 			"scope": "constant.character",
553 | 			"settings": {
554 | 				"foreground": "#0000ff"
555 | 			}
556 | 		},
557 | 		{
558 | 			"scope": "constant.character.escape",
559 | 			"settings": {
560 | 				"foreground": "#a31515"
561 | 			}
562 | 		}
563 | 	]
564 | }


--------------------------------------------------------------------------------