RubyMine 5.0.0 Web Help

Missing Web Help Page

Page Closing an Editor for a Language Injection appears to be missing.

You may try to find information you were looking for on one of the similar pages:

Editor. Editor Tabs
Referencing DTD or Schema
Viewing Changes History for a File or Selection
Intention Actions
Creating Rails Application Elements
Bookmarks Dialog
Gem Manager (Install /Update Gems)
Running Injected SQL Statements from the Editor
Editor. Smart Keys
Defining Mappings
Finding and Replacing Text in File
Creating a New Changelist
Checking Perforce Project Status
Familiarize Yourself with RubyMine Editor
Navigating to Partial Declarations
Creating and Registering File Types
Configuring Keyboard Shortcuts
Pulling Changes from the Upstream (Git Pull)
Applying Intention Actions
Analyzing Duplicates
Editor. Code Folding
Comparing Deployed Files and Folders with Their Local Versions
Viewing Details of Changes
Unit Testing Node.JS
Cutting, Copying and Pasting
Starting the Debugger Session
Managing Your Project Favorites
Exporting and Importing Settings
Creating and Editing Run/Debug Configurations
Splitting and Unsplitting Editor Window
Excluding Files and Folders from Deployment
Navigating Between Editor Tabs
Managing Enterprise Plugin Repositories
Opening, Reopening and Closing Projects
Running and Debugging Node.js
Supported Languages
Import Data Sources Dialog
Navigating to Declaration or Type Declaration of a Symbol
Configuring a DDL Data Source
Viewing Members in Diagram
Changing Placement of the Editor Tabs
Closing Files in the Editor
Deleting Tasks
Navigating Between Test and Test Subject
Finding and Replacing Text in Project
Enabling Integration with an Issue Tracking System
Menus and Toolbars
Exploring Frames
RubyMine Tool Windows
Table Editor Properties Dialog
Working Offline
Handling LF and CRLF Line Endings
Editor. Colors and Fonts
Rails View
Enabling Version Control
Accessing the Authentication to Server Dialog
Internationalization and Localization Support
Commenting and Uncommenting Blocks of Code
Unwrapping and Removing Statements
What's New
Configure Ignored Files Dialog
Navigating to Action
Configuring Menus and Toolbars
Documenting Source Code in RubyMine
Manipulating the Tool Windows
Viewing Modes
Creating Actions
Log Tab
Project and IDE Settings
Find Tool Window
Opening and Reopening Files in the Editor
Moving Items Between Changelists in the Changes Tool Window
Cloning a Repository from GitHub
Basic Code Completion. Completing Names and Keywords
Configuring Intention Actions
Enter Keyboard Shortcut Dialog
Installing, Updating and Uninstalling Repository Plugins
Interactive Console
Viewing Changes Made by Other Team Members
Common Version Control Procedures
Building Call Hierarchy
Associating a Project Root with Version Control System
Deleting Node Elements from Diagram
Creating Files from Templates
Interactive Rebase
Resetting Head Commit
Create and Run Your First Project
Escaping Characters in Velocity Variables and Directives
SVN Repositories
Adding Tags
Thumbnails Tool Window
Running Applications
Viewing JavaScript Reference
Viewing Structure and Hierarchy of the Source Code
Managing Editor Tabs
Setting Up a Local Git Repository
XML Catalog
Navigating Between Files and Tool Windows
Creating and Editing Live Templates
Monitoring Code Coverage for JavaScript
Find Usages Dialogs
Console Folding
Using Git Integration
Configuring JavaScript Debugger
CSS-Specific Refactorings
Debug Tool Window
Saving and Reverting Changes
Specifying a Version to Work With
Configuring a DB Data Source
Specify Inspection Scope Dialog
Adding, Deleting and Moving Lines
Using Mercurial Integration
Setting Up a Local Mercurial Repository
Edit Subversion Options Related to Network Layers Dialog
Editor. Appearance
Live Template Abbreviation
Checking In Files
CVS Tool Window
Stashing and Unstashing Changes
Browsing Subversion Repository
Commit Changes Dialog
Feedback Page
Running and Debugging
Accessing Project Structure
Configuring Folders Within a Content Root
Git Branches in Multirooted Projects
Accessing the Database Tool Window
Changing Properties of a Data Source
Select Path Dialog
Local, Repository, and Incoming Changes
Debug Tool Window. Dump
Creating and Editing Template Variables
Configuring HTTP Proxy
Deployment: Mappings Tab
Breakpoints Icons and Statuses
Accessing Default Project Settings and Structure
Analyzing Applications
Stopping and Pausing Applications
Creating Test Templates
Viewing Differences in Properties
Resolving References to Missing Gems
Working with Consoles
Copy and Paste Between RubyMine and Explorer/Finder
Edit Template Variables Dialog
Viewing Query Results
Code Duplication Analysis Settings
Debug Tool Window. Console
Rename Refactorings
Pulling Changes from the Upstream (Pull)
Open Task Dialog
Pinning and Unpinning Tabs
Detaching Editor Tabs
Viewing HTML Source Code of a Web Page in the Editor
Configuring General VCS Settings
Using Macros in the Editor
Disabling Intention Actions
Running Rails Server
Uploading and Downloading Files
Unified Version Control Functionality
Configuring Colors and Fonts
Creating Folders and Grouping Run/Debug Configurations
Pausing and Resuming the Debugger Session
Resolving Conflicts
Shelving Changes
Folding and Expanding Code Blocks
Setting Labels to Variables, Objects and Watches
Defining TODO Patterns and Filters
Diagram Toolbar and Context Menu
Defining the Set of Changelists to Display
Adding Data Structure Definition Files to a DDL Data Source
Specifying the Appearance Settings for Tool Windows
Temporary and Permanent Run/Debug Configurations
Creating and Optimizing Imports
Analyzing External Stacktraces
Configuring Local Ruby Interpreters
CoffeeScript Support
Diagram Preview
Accessing Breakpoint Properties
Viewing Local History of Source Code
Managing Plugins
Advanced Options Dialog
Editor. Auto Import
Creating and Saving Temporary Run/Debug Configurations
Loading Code from Editor into Console
Run/Debug Configuration: Rake
Selecting Files and Folders
Code Inspection
Updating Local Information
Handling Modified Without Checkout Files
Viewing Merge Sources
Extract Parameter in JavaScript
Enable Version Control Integration Dialog
Scope Language Syntax Reference
Creating and Editing File Templates
Managing Branches
Resolving Text Conflicts
Manipulating Table Data in the Table Editor
Viewing Styles Applied to a Tag
Test::Unit and Related Frameworks
Terminating Tests
Using GitHub Integration
Using Drag-and-Drop in the Editor
IntelliJ Configuration Server Settings
Simple, Parameterized and Surround Live Templates
Rerunning Applications
Add Server Dialog
Defining Scope-Profile Combination
Navigating Between Methods and Tags
Undoing and Redoing Changes
Folding and Expanding Custom Blocks
Switching Between Contexts
JavaScript-Specific Refactorings
Viewing Images
Test::Unit Special Notes
Compare Files and Folders
Reporting Issues and Sharing Your Feedback
Pull Changes Dialog
Changes Browser
Repository and Incoming Tabs
Accessing Project Settings
Accessing Inspection Settings
Refactoring Source Code
Assembling a CVS Root String
Creating Models
DDL Data Source Properties
Reverting Local Changes
Guided Tour Around RubyMine User Interface
Creating Exception Breakpoints
Configuring Global CVS Settings
Rebasing a Branch to a Specific Commit
Managing Tasks and Context
Using JavaScript Code Quality Tools
Logs Tab
Creating and Managing Projects
Creating and Editing Properties Files
Creating Property Keys and Values
Code Coverage
Deleting a Changelist
Rebasing Branches
Using Multiple Perforce Depots with P4CONFIG
Exporting Information From Subversion Repository
Viewing and Managing Integration Status
Creating Views from Actions
Safe Delete Dialog
Add / Edit Pattern Dialog
Keyboard Shortcuts By Category
Configuring Individual File Encoding
Previewing Pages with Web Contents in a Browser
Configuring Behavior of the Editor Tabs
Advanced Editing Procedures
Viewing Structure of a Database or Table
IDE Settings
Local History
Comparing Data Sources
Specify Code Duplication Analysis Scope
Coverage Tool Window
Files/Folders Default Permissions Dialog
JavaScript. Usage Scope
Overriding Methods of a Superclass
Navigating with Structure Views
Zooming in the Editor
Configuring Load Path
Extract Variable in JavaScript
Database Console Properties Dialog
JSTestDriver Server Tool Window
Sharing Directory
Running Capistrano Tasks
Attaching and Detaching Perforce Jobs to Changelists
Integrating Changes to Branch
Using the Bundler
Viewing Gem Environment
Directory-Based Versioning Model
TODO Tool Window
Using Suggestion List
Extract Variable
Integrating Project
Grouping Changelist Items by Folder
Checking Git Project Status
Creating a New Branch
Installing Gems for Testing
Extract Module Dialog
Inline Method
Macros Dialog
Push Rejected Dialog (Git)
Show History for Folder Dialog
Viewing Usages of a Symbol
Resolving Commit Errors
Update Directory / Update File Dialog (CVS)
Revert Changes Dialog
Surrounding Blocks of Code with Language Constructs
Fetching Changes from a Remote Git Repository
Accessing Data Sources via the Database Console
Configuring JavaScript Libraries
Enabling Cucumber Support in Project
Viewing Diagram
Code Style. YAML
Deployment: Connection Tab
Remote Host Tool Window
Version Control with RubyMine
Refreshing Status
Selecting Text in the Editor
Code Style. JavaScript
Git Push Dialog
Changing Highlighting Level for the Current File
Viewing Recent Changes
Using Help Topics
Ruby Gems Support
Embedding a Rails Mountable Engine into a Rails Application
Extract Dialogs
Changelist Conflicts
DB Data Source Properties
Viewing Reference Information
Creating Run/Debug Configuration for Tests
Specifying Actions to Confirm
Browsing Through the Gems Repositories
Changing Indentation
Injecting Ruby Code in View
Enter Mouse Shortcut Dialog
Hierarchy Tool Window
Register RubyMine
Finding Word at Caret
Configuring Code Coverage Measurement
Shelving and Unshelving Changes
Specifying Additional Connection Settings
Output Filters Dialog
Navigating to Class, File or Symbol by Name
Extract Constant
Creating Git Gists
Using DRb Server
Extract Variable Dialog
Schemas and DTDs
Edit Tool Dialog
Live Templates
Rebasing Commits Dialog
Working with Annotations
Applying a Branch Entirely on Top of Master
Version Control
Run Tool Window
Importing RubyMine Settings on First Launch
Adding, Editing and Removing Watches
Configuring Autofolding Behavior
Enabling and Disabling Plugins
Saving and Clearing Contexts
Running Rails Scripts
Viewing Model Dependency Diagram
Ignore Unversioned Files
Customizing Profiles
Safe Delete
Handling Passwords for Git Remote Repositories
Publishing a Project on GitHub
Run/Debug Configuration: Rack
Code Style. Gherkin
Configuring Quick Lists
Configuring Third-Party Tools
Creating Imports
Reviewing Results
Editing Macros
Documentation Look-up in External JavaScript Libraries
Unit Testing JavaScript
Using TODO
Create Property Dialog
Subversion Reference
Creating Empty Files
Viewing Structure of a Source File
Adding Files to Version Control
Using YARD Annotations
Editor. Code Completion
Master Password / Reset Master Password Dialog
Browse Repositories Dialog
Basic Editing
Local Tab
Configuring Inspection Severities
Configuring Browsers
Navigating with Breadcrumbs
Viewing the GitHub Version of a File
Using Perforce Integration
Editing Model Dependency Diagrams
Debugging JavaScript
Run/Debug Configuration: Node JS Remote Debug
Accessing the IDE Settings
Importing Project from Existing Source Code
Extract Parameter
Navigating Back to Source
Associating a Directory with a Specific Version Control System
Checking Out Files from CVS Repository
Merging, Deleting, and Comparing Branches
Viewing Contents of a Folded Block
Creating and Importing Data Sources
Creating .feature Files
Using Consoles
Rename Dialog for a File
Perforce Options Dialog
New Changelist Dialog
Debug Tool Window. Watches
Sharing Settings
Initial Setup
Rerunning Tests
Using Change Markers to View and Navigate Through Changes in the Editor
Switching Between Working Directories
Creating Rails Application and Rails Mountable Engine Projects
Zen Coding Support
Differences Viewer for Folders and DB Objects
GitHub Integration Reference
Mercurial Reference
Accessing the CVS Roots Dialog Box
Integrating Files and Changelists from the Changes Tool Window
Highlighting Braces
Markup Languages Tips and Tricks
Run/Debug Configuration: Node JS
File Types
File Status Highlights
Navigating with Bookmarks
Integrating Perforce Files
Viewing TODO Items
Productivity Guide
Comparing Files
Function Keys
Reset Head Dialog
File Template Variables
Configuring History Cache Handling
Browsing Contents of the Repository
Adding Node Elements to Diagram
Optimizing Imports
Navigating to File Path
Navigating to Navigated Items
Copying, Renaming and Moving Files
Importing a Local Directory to CVS Repository
Using Subversion Integration
Checking Out Files from Subversion Repository
Adding Plugins to Enterprise Repositories
Enabling Creation of Documentation Comments
Previewing Compiled CoffeeScript Files
Viewing Inline Documentation
Configuring Default Settings for Diagrams
Ignored Files
Add / Edit Filter Dialog
Keyboard Shortcuts and Mouse Reference
General Techniques of Using Diagrams
Duplicates Tool Window
Event Log
File Templates
Live Template Variables
Move Refactorings
Showing Revision Graph and Time-Lapse View
Quick Installing Gems
Evaluate Expression
Using Productivity Guide
Change Master Password Dialog
Import into CVS
Git Reference
Update Project Dialog (Git)
Inspection Tool Window
Running Inspections
Exporting Inspection Results
Viewing Inline Documentation
Changing Read-Only Status of Files
Run/Debug Configuration: Gem Command
Code Style. CSS
Code Style. LESS
External Diff Tools
Menus and Toolbars
Groups of Live Templates
Creating Code Constructs by Live Templates
Resolving Conflicts with Perforce Integration
Locking and Unlocking Files and Folders
Navigating with Model Dependency Diagram
Using Online Resources
Rebase Branches Dialog
SVN Checkout Options Dialog
Update Project Dialog (Subversion)
Table Editor
Tuning RubyMine
Smart Type Code Completion. Completing Code Based on Type Information
Viewing Recent Find Usages
Extract Module
Navigating to Source Code from the Debug Tool Window
Configuring Version Control Options
Deleting Files from the Repository
Unshelving Changes
Updating Local Information in CVS
Adding Files to a Local Git Repository
Checking out (Switching Between Branches)
Adding Files To a Local Mercurial Repository
Configuring Subversion Branches
Integrating SVN Projects or Directories
Working with Models in Rails Applications
RubyMine-Specific Navigation
Capifying Application
Testing Frameworks
TODO Example
Configuring Output Encoding
Run/Debug Configuration: Query Language Console
Run/Debug Configuration: Ruby
Usage Statistics
Code Folding
Show History for File / Selection Dialog
Documentation Tool Window
Test Runner Tab
Disabling Inspections
Viewing Offline Inspections Results
Highlighting Usages
Viewing and Exploring Test Results
Using CVS Watches
Configuring Available Ruby Interpreters
Phusion Passenger Special Notes
Running Rake Tasks
Run/Debug Configurations
Run/Debug Configuration: NodeUnit
Run/Debug Configuration: Rails
Code Quality Tools
Insert, Delete and Navigation Keys
Stash Dialog
Unstash Changes Dialog
Create Gist Dialog
Switch Working Directory Dialog
Import into Subversion
Apply Patch Dialog
Unshelve Changes Dialog
Spork DRB Server
Status Bar
Working With Search Results
Creating Line Breakpoints
Running with Coverage
Using Patches
Customizing Upload
Collecting Code Coverage with Rake Task
Enabling Test Runner UI for Cucumber Features
Navigating from .feature File to Step Definition
Editing Files Using TextMate Bundles
Code Style. Ruby
Code Style. CoffeeScript
SQL Dialects
Working with Background Tasks
Custom Plugin Repositories Dialog
Check Out From CVS Dialog
Integrate File Dialog (Perforce)
Link Job to Changelist Dialog
Select Branch
Messages Tool Window
Project Tool Window
Icons Reference
Configuring Code Style
Populating Projects
Building Class Hierarchy
Viewing Definition
Running Tests
Viewing Code Coverage Results
Getting Local Working Copy of the Repository
Reverting to a Previous Version
Configuring CVS Roots
Accessing Git Branches Popup Menu
Enabling and Configuring Perforce Integration
Working With Subversion Properties for Files and Directories
Ruby Version Managers
Creating Relationship Links Between Models
Writing and Executing SQL Commands in the Database Console
Running JavaScript Unit Tests in Browser
Export to HTML
Extract Variable Dialog for SASS
Familiarize Yourself with IDE Navigation
Running and Debugging
Rollback Actions With Regards to File Status
Integrate to Branch
Update Info Tab
Configuring Project Settings
Cleaning System Cache
Completing Path
Hippie Completion. Expanding Words
Running Inspections Offline
Navigating to Next/Previous Error
Navigating Through the Hierarchy of Methods
Finding Usages
Finding Usages in Project
Extract Field
Extract Partial
Configuring Breakpoints
Examining Suspended Program
Monitoring and Managing Tests
Generating Code Coverage Report
Editing Multiple Files Using Groups of Tabs
Configuring Ignored Files
Configuring VCS-Specific Settings
Integrating Differences
Running RubyMine as a Diff or Merge Command Line Tool
Using CVS Integration
Working with Tags and Branches
Code Folding
Working Offline
Creating Branches and Tags
Importing a Local Directory to Subversion Repository
Viewing and Fast Processing of Changelists
Filtering Out Extraneous Changelists
Diagnosing Problems with Subversion Integration
Using Gem Manager
Installing and Uninstalling Gems
Generating Archives
Navigating to Controllers, Views and Actions Using Gutter Icons
Reloading Rake Tasks
Using RSpec in Rails Applications
Configuring Color Scheme for Consoles
File Cache Conflict
Configure Your Working Environment
Project Structure Dialog
Debugger. Ruby
Navigation In Source Code
Mark Resolved Dialog (Subversion)
Shelved Changes
Debug Tool Window. Variables
Getting Started with RubyMine
Rails-Aware Code Completion
Finding the Current Execution Point
Checking SVN Project Status
Remote Hosts
Extract Parameter Dialog for JavaScript
Run/Debug Configuration: Test::Unit/Shoulda/MiniTest
Deployment: Excluded Paths Tab
HTTP Proxy
Version Control Reference
Integrate Project Dialog (Subversion)
Suppressing Inspections
Viewing Method Parameter Information
Extract Method
VCS-Specific Procedures
Configuring Format of the Local Working Copy
Configuring Remote Interpreters via Virtual Boxes
Working with Rails Mountable Engine Projects
Creating JavaScript Unit Tests
Recent Changes Dialog
Reformat Code Dialog
Run/Debug Configuration: RSpec
Edit Log Files Aliases Dialog
Comparing Folders
Issue Navigation
New File Type
Database Console Tool Window
Database Tool Window
Types of Breakpoints
Creating Symbols From Usage
Completing Punctuation
Viewing Hierarchies
Navigating to Braces
Accessing VCS Operations
Ignoring Files
Registering GitHub Account in RubyMine
Opening Tasks
Reformatting Source Code
Creating JSDoc Comments
New Project Dialogs
Optimize Imports Dialog
Extract Superclass Dialog
Pull Members Up Dialog
Run/Debug Configuration: Cucumber
Project Settings
JavaScript. Libraries
Add Issue Navigation Link Dialog
Add Filter Dialog
TextMate Bundles
Navigation Between Bookmarks
Keyboard Shortcuts By Keystroke
CVS Global Settings Dialog
CVS Roots Dialog
Merge Branches Dialog
Push Dialog
Perforce Reference
Update Project Dialog (Perforce)
Lock File Dialog (Subversion)
Tool Windows Reference
Filters and Ordering Dialog
Live Templates
Generating Code
Welcome Screen
Running Inspection by Name
Navigation Bar
Viewing Pages with Web Contents
Navigating Through the Source Code
Navigating to Next/Previous Change
Navigating to Recent File
Searching Through the Source Code
Pull Members Up
Evaluating Expressions
Monitoring the Debug Information
Restoring a File from Local History
Putting Labels
Restoring Unshelved Changes
Filtering Out and Removing Unshelved Changes
Viewing File Status
Committing Changes to a Local Git Repository
Pushing Changes to the Upstream (Git Push)
Pushing Changes to the Upstream (Push)
Cleaning Up Local Working Copy
Configuring Subversion Repository Location
Switching Between Tasks
Language and Framework-Specific Guidelines
Bundling Gems
RVM Support
Navigating Between Rails Components
Creating Rake Tasks
Generating a Data Structure Definition (DDL) File
Markup Languages and Style Sheets
Creating a Server Configuration
Using RSpec in Ruby Projects
Mapping Color Schemes
Navigating Through a Diagram Using Structure View
Running Rails Console
Export Test Results
Refactoring Dialogs
Copy Dialog
Inline Dialogs
Move File Dialog
Settings Dialog
Code Style. XML
Working with RubyMine Features from Command Line
Basic Concepts
Web Browsers
Configure Subversion Branches
Create Branch or Tag Dialog (Subversion)
Keymap Reference
Diagram Reference
Run/Debug Configuration
Structure Tool Window
Version Control Tool Window
History Tab
Regular Expression Syntax Reference
Opening Multiple Projects
Configuring Content Roots
Moving Breakpoints
Handling Differences
Assigning an Active Changelist
Browsing Changes
Creating Gemfile
Changing Color Values in Style Sheets
Extract Partial Dialog
Extract Field Dialog
Extract Parameter Dialog
Run/Debug Configuration: Capistrano
Run/Debug Configuration: JavaScript Debug
I18n Folders
Debugger. JavaScript
Keyboard Shortcuts You Cannot Miss
Content Root
Clone Repository Dialog
Login to GitHub Dialog
Subversion Options Dialog
Subversion Working Copies Information Tab
Select Target Changelist Dialog
Debug Tool Window. Frames
Favorites Tool Window
Resolving Problems
Remote Debugging
Creating Empty Project
Binding Macros With Keyboard Shortcuts
Working with Diagrams
Extract Constant Dialog
Run/Debug Configuration. IRB Console
Run/Debug Configuration: Ruby Remote Debug
Run/Debug Configuration: Spork DRb
File Colors
Navigation Between IDE Components
RubyMine Usage Guidelines
Creating Projects from Scratch in RubyMine
Configuring Project Structure
Auto-Completing Code
Viewing External Documentation
Navigating Between IDE Components
Extracting Hard-Coded String Literals
Stepping Through the Program
Using Local History
Navigating to Source Code
Viewing Changes Information
Configuring Remote Ruby Interpreters
Creating Examples Table in Scenario Outline
Viewing Changes as Diagram
Differences Viewer
Find Usages. Class Options
Find Usages. Method Options
Find Usages. Variable Options
Login to IntelliJ Configuration Server Dialog
Rails Application Settings
Change Signature Dialog for JavaScript
Push Members Down Dialog
Rename Dialogs
File Templates
Quick Lists
Supported Version Control Systems
Set Property Dialog (Subversion)

Go to Web help home page.