#Rubymine debug install
#Rubymine debug code

When a program reaches a breakpoint and stops, you can investigate the state of the application and the values of variables in different places. In this case, the script will be executed until the next breakpoint is hit. The debugger will execute the remaining lines of the method and set the execution pointer at the statement following the method call.įinally, you can resume program execution by clicking the button ( F9 / ⌥⌘R). If you no longer want to debug a method (e.g., the one you’ve just stepped into), you can simply step out ( Shift+F8) of it. The debugger will jump right to this line. To do this, click the Run to cursor button or press Alt+F9 / ⌥F9 at the required caret position.

#Rubymine debug code

It allows you to stop the code executing at the caret position without adding another breakpoint. One more useful stepping feature is Run to cursor. Press F7 several times to walk through each line of the solve method until you return back to the second method call (line 11). In our example, the debugger steps into the solve method and stops at the first method line. To step into the method, click the button on the toolbar or press F7. Go to Smart step into, block breakpoints and more to learn more. If there are multiple method calls or blocks, you can choose the desired target by using the new smart step into functionality.

Clicking F8 another time takes us to the puts method call (and skips going into the solve method).Īnother way of stepping through the code is to use step into which causes the debugger to go into the method calls or blocks on the current line and follow them through. In our case, the IDE then steps over the solve method and goes to the 11th line – to the calculation of the second root. To step over, click the button in the debugger’s toolbar or press F8. Step over will proceed to take us to the next line in the current scope (for example, it will take us to the next line), without going into any method calls on the way. Let’s see what capabilities RubyMine provides to step through program execution further. Note that x1 is not evaluated because the solve method is not called yet.

The editor displays the current variable values on the right. Stepping through a programĪfter starting the debugging session, RubyMine stops execution on the 10th line. That’s it! We are ready to start debugging.

#Rubymine debug install

If your project SDK doesn’t have debugging gems installed, RubyMine will suggest that you install them: Press and hold down the Shift key (the dialog title will be changed to Debug) and press Enter.Press Ctrl twice and type the following command in the invoked popup: ruby script.rb.To start a debugging session, do the following: The script will be suspended at this line and we can check the program’s state. Alternatively, you can place the caret on this line and press Ctrl+F8 / ⌘F8. To do this, click the left gutter next to this line. This method accepts equation coefficients and a sign so you can determine both roots.īefore starting a debugging session, let’s set a breakpoint next to the following line: x1 = solve(a, b, c, 1) In this script, the x1 and x2 equation roots are determined by calling the solve method.

(-b + (sign) * Math.sqrt(discriminant)) / (2 * a) This will be a script for solving a quadratic equation without additional checks (for example, whether or not the discriminant is equal to or less than 0): a = 1 Smart step into, block breakpoints and moreįirst, let’s create a new Ruby project from scratch.Let’s dig a little deeper into the debugging process and see how we can start a debugging session, set and configure breakpoints, evaluate variables and expressions, and all the other little useful things you should know about in between. All of these features are applied to Ruby projects and Rails applications. The RubyMine debugger provides various ways to examine the state of a running application: you can step through your code and check variable values, set watches on variables to see when values change, and so on. These include performance optimizations, Smart Step Into, block breakpoints, and others. In this blog post, we’ll review the rich debugging capabilities available in RubyMine and then we’ll have a quick rundown of the new debugging features added in v2019.2. One of the main advantages of IDEs over text editors is the debugging experience. To learn more about debugging capabilities available in RubyMine, refer to the help topics and tutorials from the Debug section.