RubyMine 2020.2

Adds new way to review problems in code plus full support for GitHub pull requests.
July 31, 2020 - 9:00
New Version

Features

Code insight

  • A new way to review and fix problems in code - Added a new widget that shows the number of issues in the current file. Clicking it opens a tool window with a list of those issues. From there, you can jump to the code containing an issue, or you can fix issues directly from the tool window.

Liquid template language

  • Basic support for Liquid template language - RubyMine 2020.2 includes basic support for the Liquid template language. The IDE will show you if there are any issues with the syntax, provide live templates to insert frequently used constructions, and reformat the code according to the requirements you’ve specified in the Code Style settings.

New smart intention actions

  • Flip ternary and if-else operators - With the Invert ‘if-else’ action, you are able to flip an if-else operator so that the condition is negated and the branches are switched. For ternary operators, there’s the Flip ‘?:’ intention action which works the same way.
  • Switch between nested ‘if’ statements and boolean expressions - Use the Merge nested ‘if’ action to merge a nested statement into a boolean expression. To invoke this action, place the caret on the outer if of the expression. Split into multiple ‘ifs’ performs the opposite action, and is available with the caret on the boolean operator.
  • Switch between ‘else/if’ and ‘elsif’ statements - With the Merge ‘else if’ and Split ‘elsif’ intention actions, you can split an elsif statement into a nested else/if branch and vice versa.
  • Merge/split sequential ‘if’s - The Merge/split sequential ‘if’s action is available on the elsif or if keywords. It suggests merging two branches if the code inside these branches is exactly the same. RubyMine will then combine the two conditions using an || operator and add parentheses if necessary. The Split into multiple ‘if’s action will do the opposite.
  • Expand or flatten namespace - These intention actions will expand lines with the :: scope resolution operators into nested modules and vise versa. Note that the Flatten namespace action will flatten the modules above it.
  • Sort hashes by their keys - Use this intention action to sort hashes alphabetically by their key. It also works for hashes with different key types. In this case, the keys are grouped by their type and then sorted.
  • Add/remove clarifying parentheses - The Add clarifying parentheses intention action works for binary and ternary expressions. It adds parentheses to complex expressions that rely on operator precedence, in order to clarify how the expression should be evaluated. You can also call Remove unnecessary parentheses.
  • Add/remove underscores in numbers - The Add underscores action adds underscores for large numbers to aid readability. The supported types are integer/float/octal (adds an underscore every 3 digits) and hexadecimal/binary (puts underscores every 4 characters/digits).
  • Introduce a new local variable - Use this intention action to introduce a new local variable when the caret is placed on an expression.
  • Inline local variable - This intention action is useful during refactoring in cases where you find yourself left with a variable that is only used once.
  • Switch between block and line comments - You can now convert block comments into line comments and vice versa. Note that these actions are only available for comments that begin at the start of the line, as block comments require this.

Code editor

  • Improved readability of folded if/while/for statements - For folded constructs, like if, while, and for, RubyMine now displays the condition or variables used in the first line. This approach makes it easier to see whether you need to unfold the construct and look into it.
  • In-editor RDoc/YARD documentation comments rendering - Reading RDoc or YARD docs in the editor can be annoying because of all the tags you have to wade through, especially when you need to interact with the reference links and images. This is why this release adds a way to render documentation directly in the editor.
  • Heredoc injections - RubyMine now supports heredoc injections that allow you to define a multiline string while maintaining the original formatting and indentation. Use it to embed snippets of code, like HTML or SQL.
  • Improved navigation between methods - You can now navigate between the super and overriding methods by calling an intention action or by clicking the icon in the gutter.

Ruby

  • Support for beginless ranges - As always, RubyMine supports the latest version of Ruby. For example, RubyMine v2020.2 supports beginless ranges, which were introduced in Ruby 2.7.
  • Improved completion for standard library methods - RubyMine now suggests much more accurate completion for a variety of standard library methods, including Array#sort_by, Hash#each, and many others.
  • Convert named parameters to numbered and vice versa - You can now easily convert named parameters into numbered ones, introduced in Ruby 2.7. Place the caret over any named parameter, press Alt+Enter, and pick the Convert named parameters to numbered intention action. The Convert numbered parameters to named action will do the opposite.
  • Add an attr_accessor/reader/writer to an instance variable - With the new intention actions, you can easily add an attribute accessor, reader, or writer to instance variables. To do so, place the caret on a variable, and press Alt+Enter.

Rails

  • Expand lazy keys - In Rails applications that use lazy keys (lazy lookups), this intention action will automatically expand the key to its full form. If there’s a lazy key in a controller, the intention may ask which lazy key to expand it to (as there can be multiple options).

Git

  • Full support for GitHub pull requests - You no longer need to switch between the browser and your IDE. The entire pull request workflow can now be completed from within RubyMine. With v2020.2, you can browse, assign, manage, and even merge pull requests, view the timeline and in-line comments, submit comments and reviews, and accept changes.
  • Improved Git actions dialogs - The Merge, Pull, and Rebase Git dialogs now have better visual consistency and less clutter. With the new design, you can quickly see which Git command will be executed. Also added the –rebase option to the Pull dialog and the –no-verify option to the Merge dialog.

JavaScript and TypeScript

  • New smart intentions for JavaScript - New smart intentions (Alt+Enter) will help you perform some actions faster. For example, you can now quickly convert a for loop with a numeric index into a forEach array method. Looking through documentation comments in JavaScript and TypeScript files has also become easier, as you can now render them directly in the editor, minimizing all distractions.
  • Make Prettier the default formatter in your JavaScript projects - Want to use Prettier instead of the built-in formatter to tidy up your code? With this update, it has become even easier than before. Just tick the new On code reformat checkbox and the IDE will use Prettier whenever you reformat your .js, .ts, .jsx, and .tsx files. Other file types can be easily added, too.
  • Support for Vue - Added Nuxt.js support, Vue-specific code style settings, improvements for Vue in TypeScript projects, and more.

Database tools

  • Separate editor for cell values - Now if you have a huge value in your cell, you can view or edit it in a separate panel. You can also toggle soft wrap mode using the right-hand toolbar.
  • A new UI for boolean values - There’s now a more user-friendly way to view and edit boolean values. True values are now marked with a bullet point to distinguish them from all the others. Editing:
    • The space key toggles values like it used to.
    • Typing f, t, d, n, g, or c will input the corresponding values: false, true, default, null, generated, and computed.
    • Typing anything else will open a drop-down list with all possible values.

Other changes

  • ML-assisted completion introduced in v2020.1 has proven effective in improving the relevance of code completion suggestions. It's now enabled by default in v2020.2.
  • New presentation of the search results in Search Everywhere, with items sorted by their relevance to the search query.
  • RubyMine 2020.2 supports Git installed in WSL2 for working with projects located in Linux or Microsoft Windows file systems.
  • You can now generate code coverage reports for multiple suites and export them to HTML.
  • Basic support for Google BigQuery. RubyMine can correctly highlight and provide coding assistance for your queries if you use Google BigQuery.
  • Code completion now shows full type names for methods that override other methods from parent classes or modules. This makes it easier to understand where a suggested method is coming from.
  • You can now launch the IRB console from Run Anything with Ruby 2.7.
  • Completion in the Gemfile now shows only the latest local version of the gems.
  • RubyMine now displays a warning if you try to pass an incorrect number of parameters to stub methods, including Array.to_h(), Dir.each(), and others.
  • Added the “ordinary parameter is defined” warning for all lambda cases in numbered parameters.
  • Added type support for the not call in active record relation chains. Now when no arguments are provided for a where method, RubyMine will offer not as a completion.
  • Improved accessibility and now RubyMine will automatically enable the accessibility features if a user has a screen-reader enabled.
Review and fix problems in code

RubyMine

Ruby on Rails IDE that provides essential tools for developers.

RubyMine is also available in:

Got a Question?

Live Chat with our JetBrains licensing specialists now.