JetBrains Rider
 
2023.1
Shortcuts: Visual Studio 2022 (Windows)
Get JetBrains Rider
You are viewing the documentation for an earlier version of JetBrains Rider.
  1. Languages and frameworks
  2. CoffeeScript

Languages and frameworks: CoffeeScript

Last modified: 21 April 2023

Required plugins:

CoffeeScript -  Install the plugin on the Settings | Plugins page, tab Marketplace.

File Watchers -  The plugin is bundled with JetBrains Rider and enabled by default.

With JetBrains Rider, you can use CoffeeScript that compiles into JavaScript. JetBrains Rider recognizes *.coffee files and marks them with the CoffeeScript icon. You can set breakpoints directly in your CoffeeScript code and JetBrains Rider recognizes them using source maps generated during compilation.

JetBrains Rider helps you write CoffeeScript code by suggesting completion for keywords, labels, variables, parameters and functions. You can jump from a symbol to its declaration F12 or implementation Alt+End as well as find any symbol by its name Ctrl+Alt+Shift+T.

JetBrains Rider integrates with the coffeescript compiler that translates CoffeeScript code into JavaScript. The tool also creates source maps that set correspondence between lines in your CoffeeScript code and in the generated JavaScript code so that JetBrains Rider debugger recognizes breakpoints in your CoffeeScript code and processes them correctly.

Before you start

Compiling CoffeeScript into JavaScript

To compile your code automatically, you need to configure a CoffeeScript File Watcher which will track changes to your files and run the coffeescript compiler.

When you open a file, JetBrains Rider checks whether an applicable File Watcher is available in the current project. If such File Watcher is configured but disabled, JetBrains Rider displays a popup that informs you about the configured File Watcher and suggests to enable it.

If an applicable File Watcher is configured and enabled in the current project, JetBrains Rider starts the compiler automatically upon the event specified in the New Watcher dialog.

  • If the Auto-save edited files to trigger the watcher checkbox is selected, the File Watcher is invoked as soon as any changes are made to the source code.

  • If the Auto-save edited files to trigger the watcher checkbox is cleared, the File Watcher is started upon save (File | Save All, Ctrl+Shift+S) or when you move focus from JetBrains Rider (upon frame deactivation).

The compiler stores the generated output in a separate file. The file has the name of the source CoffeeScript file and the extension .js or .js.map depending on the compiler type. The location of the generated files is defined in the Output paths to refresh field of the New Watcher dialog. Based on this setting, JetBrains Rider detects the compiler output. However, in the Project tool window, they are shown under the source coffee file which is now displayed as a node.

Install the CoffeeScript compiler

Create a CoffeeScript File Watcher

Customize the behaviour of the compiler

With JetBrains Rider, you can adjust the compiler by passing arguments to it just as if you were working in the command-line mode. Below is an example of customizing the default output location for the CoffeeScript compiler.

Suppose, you have a project with the following folder structure:

File Watchers example of folder structure

With the default File Watcher, the generated files will be shown as children of their original files.

Default File Watcher output

You can change this default location and have the generated files stored in a separate JavaScript folder.

Store all the generated files in the output JavaScript folder

  1. Create a CoffeeScript File Watcher.

  2. In the Arguments field, type: 

    --map --compile -o $ProjectFileDir$/JavaScript $FileName$

  3. In the Output paths to refresh field, type:

    $ProjectFileDir$/JavaScript/$FileNameWithoutExtension$.js:$ProjectFileDir$/JavaScript/$FileNameWithoutExtension$.map:$FileNameWithoutExtension$.js.map

As a result, the project tree looks as follows:

Custom output, flat structure

You can also have the generated files stored in the folder structure that repeats the original structure under the app node.

Preserve the original folder structure in the output folder

  1. Create a CoffeeScript File Watcher.

  2. In the Arguments field, type: 

    --map --compile -o $ProjectFileDir$/JavaScript/$FileDirRelativeToProjectRoot$ $FileName$

  3. In the Output paths to refresh field, type:

    $ProjectFileDir$/JavaScript/$FileDirRelativeToProjectRoot$/$FileNameWithoutExtension$.js:$ProjectFileDir$/JavaScript/$FileDirRelativeToProjectRoot$/$FileNameWithoutExtension$.map:$FileNameWithoutExtension$.js.map

As a result, the project tree looks as follows:

Custom output, folder structure preserved

Preview compilation results without running the compiler

JetBrains Rider can perform static analyses of your CoffeeScript code without actually running a compiler and display the predicted compilation output in the dedicated read-only viewer.

Running CoffeeScript

There are two ways to run CoffeeScript in JetBrains Rider:

  • Compile the CoffeeScript code manually and then run the output JavaScript code as if it were a Node.js application.

  • Run the original CoffeeScript code through the Node.js run configuration and have JetBrains Rider compile it on the fly.

Compile CoffeeScript manually and run the generated JavaScript code

  1. Compile the CoffeeScript code into Javascript.

  2. Start creating a Node.js run configuration with the following mandatory settings:

    1. The Node.js engine to use. By default, the field shows the path to the interpreter specified on the Node.js page during Node.js configuration.

    2. In the Working directory field, specify the location of the files referenced from the starting CoffeeScript file to run, for example, includes. If this file does not reference any other files, just leave the field empty. field

    3. In the Path to Node App JS File field, specify the full path to the JavaScript file that was generated from the original CoffeeScript file during the compilation.

  3. Save the configuration and click the Run button on the toolbar.

  4. Proceed as while running a Node.js application.

Compile CoffeeScript on the fly during run

  1. This mode requires that the register.js file, which is a part of the coffeescript package, is located inside your project. Therefore make sure you have the coffeescript package installed locally as described in Install the CoffeeScript compiler.

  2. Open the starting CoffeeScript file in the editor or select in the Project tool window and choose Run <CoffeeScript_file_name> from the context menu. JetBrains Rider runs the file with the automatically generated run/debug configuration.

    Alternatively, select Create <CoffeeScript_file_name> from the context menu and check the following mandatory settings in the Run/Debug Configuration: Node.js dialog that opens:

    1. The Node interpreter to use. Select the relevant interpreter configuration or create a new one. By default, the field shows the path to the interpreter specified on the Node.js page during Node.js configuration.

      For Linux and macOS, this setting is overridden by the Node.js from the path to the CoffeeScript compiler executable file.

    2. In the Node parameters field, type --require coffeescript/register.

    3. In the Working directory field, specify the working directory of the application. By default, the field shows the project root folder.

    4. In the JavaScript file field, specify the full path to the CoffeeScript file to run.

  3. Save the configuration and click the Run button on the toolbar.

  4. Proceed as while running a Node.js application.

Debugging CoffeeScript

To debug CoffeeScript in JetBrains Rider, you need source maps generated in addition to the JavaScript code. Source maps set correspondence between lines in your CoffeeScript code and in the generated JavaScript code, otherwise your breakpoints will not be recognised and processed correctly. JavaScript and source maps are generated by compiling the CoffeeScript code manually using the File Watcher of the type CoffeeScript. After that you can debug the output JavaScript code as if it were a Node.js application.

note

Debugging of JavaScript code is only supported in Google Chrome and in other Chromium-based browsers.

Debugging CoffeeScript is supported only in the local mode. This means that JetBrains Rider itself starts the Node.js engine and the target application according to a run configuration and gets full control over the session.

For more details about debugging Node.js applications, see Running and debugging Node.js.

Debug CoffeeScript code

  1. Set the breakpoints in the CoffeeScript code where necessary.

  2. Compile the CoffeeScript code into Javascript using the File Watcher of the type CoffeeScript.

  3. Start creating a Node.js run configuration with the following mandatory settings:

    1. The Node.js engine to use. By default, the field shows the path to the interpreter specified on the Node.js page during Node.js configuration.

    2. In the Working directory field, specify the location of the files referenced from the starting CoffeeScript file to run, for example, includes. If this file does not reference any other files, just leave the field empty.

    3. In the Path to Node App JS File field, specify the full path to the JavaScript file that was generated from the original CoffeeScript file during the compilation.

  4. Save the configuration and click the Debug button on the toolbar.

  5. Proceed as when starting the debugger together with a Node.js application locally.

Configuring syntax highlighting

You can configure CoffeeScript-aware syntax highlighting according to your preferences and habits.

See also

Language and Framework-Specific Guidelines

External Links