RubyMine 5.0.0 Web Help

Missing Web Help Page

Page viewing class hierarchy as a class diagram appears to be missing.

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

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

Go to Web help home page.