RubyMine 5.0.0 Web Help

Missing Web Help Page

Page Creating a Project from Downloaded Files appears to be missing.

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

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

Go to Web help home page.