Talking RubyMine with JetBrains Developer Dmitry Jemerov
One of the more interesting announcements recently coming to the Ruby community was the release of JetBrains RubyMine IDE for Ruby and Ruby on Rails applications. The Ruby community is known for not typically using an integrated development environment (IDE) such as .NET or Java developers use. Ruby developers usually stick to plain text editors such as TextMate, Vim and Emacs.
RubyMine 1.0 was released only a short time ago with the hope of luring Ruby developers in with its many features aimed at making the developer more efficient.
InfoQ had the opportunity to talk with the lead RubyMine developer, Dmitry Jemerov of JetBrains, about RubyMine and its direction.
Robert Bazinet (RB): What is RubyMine?
Dmitry Jemerov (DJ): RubyMine is a new IDE for Ruby and Rails projects from JetBrains. RubyMine is the first in the family of light-weight IDEs built on top of the IntelliJ IDEA platform, to be followed later by IDEs for Web development (HTML/CSS/JS/PHP), Python, and likely others.
RB: Who are you and what is your role on the RubyMine project?
DJ: I'm the development lead for RubyMine. My responsibilities include overall release planning, designing the architecture of the product, work on the IntelliJ IDEA platform (adapting it for use in RubyMine and other products), and general help with coding, bugfixing and support whenever that is needed.
RB: Who is the intended user of RubyMine?
DJ: At the moment our primary target audience is Rails developers, although Ruby developers working on non-Rails projects can also find many useful features in RubyMine. We're looking at other frameworks that are popular in the Ruby community, and it's possible that some of them will be supported in future versions of RubyMine.
RB: So, for developers who own IntelliJ, they can get a plugin that will give them all the functionality of RubyMine itself?
DJ: Generally, yes, the Ruby plugin for IntelliJ IDEA and RubyMine have the same functionality - they are built from the single code base. But, RubyMine uses the newer IntelliJ platform than the one publicly available now (IntelliJ 8.x) and hence some features may not be available in the plugin because of this limitation. Once IntelliJ IDEA 9 is released, the feature set of plugin and RubyMine should become equal. You can find some more answers at http://www.jetbrains.net/devnet/docs/DOC-1146
RB: Many Ruby and Ruby on Rails developers have chosen to use plain text editors such as TextMate, Vim and Emacs. Do you see those users migrating to RubyMine?
DJ: Yes, we see some of the users migrating already, and we definitely want to make RubyMine attractive to everyone who uses plain text editors. Although there will always be a performance difference between a plain-text editor and an IDE, we feel that productivity advantages provided by a great IDE overweigh this difference. In addition to that, we plan to make the level of background processing done by RubyMine more configurable, so that people who want a faster IDE at the cost of some features would be able to get that from RubyMine.
RB: Developers who are used to TextMate and use TextMate bundles, are they supported in RubyMine?
DJ: There is TextMate keyboard schema available in RubyMine and we are planning to create convertors for TextMate Color schemes and snippets (to convert them to RubyMine live templates).
Right now we do not have plans other than that but we are open for ideas and would be happy to see 3rd party plugins providing such functionality.
RB: How is RubyMine different than other Ruby/Rails IDE's such as NetBeans or Aptana RadRails?
DJ: Some of the innovative features of RubyMine are:
- Understanding the meaning of parameters of Rails-specific calls (like render, redirect_to, has_many etc.), which allows us to provide code completion, validation and refactoring assistance for parameters of these calls
- Rails-aware refactorings (renaming of controllers, views etc. correctly updating all linked parts of the app)
- Model dependency diagram giving a quick overview of the structure of a Rails application
- Very good version control integration with a number of advanced features like Shelve Changes (allowing to set aside some source code changes for a while) and Committed/Incoming Changes (easy way to browse changes done by other team members)
RB: IDE's which have tried to implement code-completion have been criticized for their lack of accuracy, how is RubyMine implementing this to ensure accuracy?
DJ: RubyMine actually understands most of the semantics of Ruby code, including some meta-programming features like "included" hooks. Because of that, it almost never needs to resort to showing the list of all identifiers in the project, and can display only the list of identifiers or members visible in the current scope.
RB: I noticed when loading up RubyMine references to JRuby, how is JRuby used in RubyMine?
DJ: Some of high-level components of RubyMine (refactoring support, some inspections and intention actions and others) are written in Ruby and run under the JRuby interpreter. We also plan to allow users to write their own RubyMine extensions in Ruby.
RB: What type of SDK does RubyMine have to allow developers to create add-ons or plugins?
DJ: As of now we do not provide an SDK similar to one available for IntelliJ IDEA. This will become available in later versions.
But some IntelliJ plugins can already be easily updated for using with RubyMine. Here is an example: http://plugins.jetbrains.net/plugin/?id=4255.
Also, it will be possible to extend RubyMine using scripts written in Ruby. You can see several such scripts under <%RubyMine_Home%>/rb/scripts folder. And in %RubyMine_Home%>/rb/api folder you can find the preliminary version of Ruby API. This approach is still in development and we are not promoting it actively just yet. In the future we are going to add a Script Manager with a UI for manipulating the scripts. But there is no exact timeframe for this.
RB: Would you elaborate a bit on the RubyMine debugger?
DJ: The debugger in RubyMine uses the same underlying engine (ruby-debug-ide) as NetBeans and RadRails, and has roughly the same feature set. It supports breakpoints (including conditional breakpoints), frames view, local variables view, threads, watches, stepping, expression evaluation. Breakpoints can also be set in ERb views. Remote debugging support has been added in RubyMine 1.0.5, released today (May 14th).
RB: What parser is RubyMine using?
DJ: RubyMine uses its own lexer and parser, developed by JetBrains internally.
RB: What type of Refactoring support does RubyMine support?
DJ: RubyMine 1.0 supports the following refactorings:
- Rename (Rails-aware, correctly updating Rails calls and files related to the element being renamed)
- Move (also with correct updating of references)
- Introduce Variable (with possibility to detect duplicates of the expression being extracted and replace them with the new variable)
- Extract Method (with full data flow analysis to detect input and output parameters)
RB: Would you give readers some details on what other refactoring support is coming the next or subsequent versions?
DJ: Here is the list of refactorings planned for RubyMine 1.2 which is to be available in mid-summer:
- Introduce Constant
- Introduce Parameter
- Introduce Field
- Inline Local
- Pull Up / Push Down
- Extract Module
RB: What type of TDD or BDD support is built into RubyMine and how do you see this being a win for developers?
DJ: RubyMine 1.0 supports Test::Unit and RSpec, and we're currently working on Cucumber support that is planned to be included in RubyMine 1.1. The Rails community has a very strong testing culture, so we feel that testing support is a must-have feature for any Ruby and Rails IDE.
RB: Does RubyMine work with all flavors of Ruby, including MRI Ruby 1.8.x, 1.9.x, JRuby, Rubinius, IronRuby, etc?
DJ: We have tested RubyMine with MRI Ruby 1.8.x, JRuby, IronRuby and MacRuby. At the moment RubyMine does not support the new language features of Ruby 1.9; support of those is planned for one of the coming versions of RubyMine.
RB: Since RubyMine supports IronRuby has this support been tested on OS X with IronRuby running under Mono?
DJ: We have not done very thorough testing of this. Such configuration is not supported out-of-the-box but it is possible to get it running after some manual configuration. If there is a demand for it, we will provide necessary support in future versions.
RB: What is coming in future versions of the IDE?
DJ: The roadmap for future versions of RubyMine can be found on our Web site:
Some of the features worth highlighting are:
- Much broader refactoring support
- Support for HAML and SASS
- RCov integration
- Database integration (built-in query runner, SQL syntax highlighting support etc.)
RB: What does the release schedule look like and will there be interim releases as bugs are addressed?
DJ: We plan to publish major versions of RubyMine every 3 to 6 months, with several bug fix updates following each major release. Between the major releases, Early Access Preview builds (snapshots of the current development version) will be published every 1 or 2 weeks.
RB: Dmitry, thank you for taking the time to talk with me today. More information about RubyMine 1.0 can be found on the JetBrains website.