Instant RubyMine Assimilation

Point your browser to the previous address and download the free trial of the software. This will be in the form of a standard Mac OS X disk image (DMG), as shown in the following screenshot:

Open the Disk Image (DMG) and drag the RubyMine file from the DMG to your Applications folder. As shown in the following screenshot, you can now open RubyMine from your Application folder by double-clicking on the RubyMine application:

Figure 1.2

The first window that you will see is the standard Mac OS X security warning about opening an application from the Internet, depending on your security settings. Select the Open button to continue.

We will then be presented with the opening Welcome window in RubyMine. We have successfully installed RubyMine and can proceed to the next lesson.

Download the RubyMine installer from http://jetbrains.com/ruby.

Click on the RubyMine executable and the first window that you will see is the standard Windows security warning about opening an application, depending on your security settings.

Select the Run button to continue. You will get the following RubyMine setup wizard window:

Follow the standard installation steps and select the defaults for the options presented.

When the installation finishes, you will be given an option to run RubyMine. Do this and you will see a screen that will ask you to import your settings from a prior version and then a screen asking for your license.

If you have a license, enter the two pieces of information into the fields provided and then hit OK.

Otherwise, just select the option Evaluate for free for 30 days and you will have your 30-day trial of the software. You can always enter your license later—after you have been assimilated.

Continue on and agree to the license agreement, and you will then be shown a screen similar to Figure 1.2, the screen showing the message Welcome to RubyMine.

Point your browser to the same URL http://jetbrains.com/ruby and select the Download Free Trial link. This will begin the download of a .tar.gz file and depending on your environment, your browser might ask you to open it with the Archive Manager option, as shown in the following screenshot:

Select OK and the archive manager will show us a folder of the uncompressed files.

Click on the Extract button on the top toolbar of the archive manager and select your home folder to save the folder into.

Once extracted, we can then navigate to the new RubyMine folder and we will see a file called Install-Linux.tar.txt.

Follow the instructions contained in this file to complete the installation.

The main item to pay attention to is the second option in the file:

2. Open a console (ctrl-alt t) and cd into "{installation home}/bin" and type:

./rubymine.sh

to start the application.

Doing this will begin the application installation process.

A screen showing the options to agree to the license and the option checked for the 30-day trial will be presented with a screen like this:

Select the defaults for now and hit OK to continue.

Open RubyMine and you will be presented with the Welcome to JetBrains RubyMine window:

Select the option Create New Project.

Use the name HelloWorld in the first box and leave the other two options as default. We are going to start with a simple Ruby application, even though RubyMine can create many different types of project such as a Ruby on Rails project and Twitter Bootstrap Web project.

Your next task is to create a new Ruby file that we can use to begin building our first program.

Navigate to File | New … and you will be presented with a list of various choices of files to create.

Choose the File item, which is simply a Ruby file.

Name it helloworld.rb. Don't forget the .rb extension, as this is necessary to distinguish it from a simple text file, which it really is anyway.

Now, type in the following program into this new document that you created:

puts "Hello Biological Life Form. We are the Borg."
puts "We will add your biological and technological distinctiveness to our own."
puts "Resistance is futile."

Navigate to Run | Run and you will see a window similar to this:

Select the helloworld configuration and it will execute your first Ruby script. The output of your program should then be shown in a window panel below your helloworld.rb file. Each puts command prints out the string to the console and appends a carriage return to the end automatically. RubyMine captures this output in the window at the bottom of the program.

Click on the gray arrow to open up this setting, as shown in the following screenshot:

Then, click on the Colors and Fonts setting. This window will let you change the overall theme for the entire RubyMine window system.

Click on the default pull-down menu and select the theme Darcula.

Hit OK at the bottom of this window and RubyMine will confirm that you want to change the look and feel of the program.

Select OK in this dialog box and your theme will be set. RubyMine will then ask you to restart the program and you will then be able to see your changes completely. The environment should now look something like this:

Right-click on the HelloWorld project folder in the left project panel and add a new file to your project. Name it pdf.rb.

Add the following code to this new file:

require 'prawn'
Prawn::Document.generate("hello.pdf") do |pdf|
  pdf.font "Courier"
  pdf.stroke_color = "ff0000"
  pdf.line_width = 5
  pdf.stroke do
    pdf.circle([300, 300], 100);
    pdf.circle([350, 320], 20);
    pdf.circle([260, 325], 20);
    pdf.curve [270, 250], [340, 250], :bounds => [[270, 270],[275, 220]]
  end
  pdf.move_down(300)
  pdf.font_size = 36
  pdf.fill_color "000000"
  pdf.draw_text("You will be assimilated!", :at => [40, 40])

  pdf.line_width = 1
  pdf.stroke_color = "0000ff"
  pdf.move_to([0, 0])
  grid = 11
  num_lines = 51
  size = (num_lines - 1) * grid
  pdf.stroke do
    51.times do |idx|
      pdf.line([0, idx*grid], [size, idx*grid])
      pdf.line([idx*grid, 0], [idx*grid, size])
    end
  end
end

Now, right-click on the open source file and select Run pdf. You should get an error similar to in 'require': cannot load such file -- prawn (LoadError). This means that you do not have the required technology to continue the assimilation process. We need to add some Ruby Gems to allow our program to continue.

Open the Settings panel and select the Ruby SDK and Gems panel from the left-hand list. This is where we also changed the version of Ruby that we are using. This panel will allow us to install some specific Ruby Gems that we need.

Hit the button Install Gems... and you will see a screen like the following:

Start typing the name of the Gem you wish to install, which in this case is prawn and the search will begin immediately. Scroll to the right Gem.

Select the Gem in the list at the left-hand side and then hit the button Install. RubyMine will then run the Gem system and install the Gem and all of its appropriate dependencies into your system.

When it is complete, select the prawn gem in the list on the right and you will see the description panel filled with various aspects of the gem for your browsing pleasure.

Once completed, go back and re-run the pdf.rb program.

Since this program actually generates a PDF file, we need to find where it saved the file. In the project window on the left, hit the icon that looks like the following:

This will synchronize the files inside the folder with the project list. You should now be able to see the file hello.pdf in the project window.

Double-click on this and you will see this file in whichever application you have on your computer that displays PDF files. You should see something like the following:

At the top of the window, select the green arrow to run the Development: Progeny configuration. Running, in this case, means that it will start the default Rails webserver, Webrick, and begin listening on port 3000 for web browser requests.

Once it is running, open your favorite browser and go to the address http://localhost:3 000, and you should see the opening Rails Welcome Aboard screen.

Click on the link About your application's environment, you can see some details about your installation including the various version numbers of Rails and Ruby, and the database that your application will be using.

To run the generators, we just need to navigate to Tools | Run Rails Generator.

As you type, the list is filtered to match your selection. Select the scaffold generator and hit Return:

The following window gives us the opportunity to name our table and the various fields that it will contain. The database table will become the name of our model as well.

Type the following into the top text box:

Species name:string identification:integer assimilated:Boolean

Leave the other settings at their default and hit OK, as shown in the following screenshot:

Now if you reload your browser window, you should see an error like ActiveRecord:: PendingMigrationError.

Oops! We forgot to do something after creating the code for the database tables. We need to run the migrations that will create the actual tables.

Navigate to Tools | Run Rake Task… and start typing db:migrate. Just like the generator window, the various rake tasks will begin to be filtered by what you type.

Hit Return and then select the defaults in the next window Latest migration and the migrations will be run for you.

Now that the tables are created, point your browser to a new location, http://localhost:3000/species. You will see the index page for your Species database table, similar to the following screenshot:

Click on the links and add some species to your database. The scaffolding that we generated, produced all of the CRUD (Create Read Update Delete) forms and screens necessary for managing our Species database table, without typing any commands in our terminal or leaving RubyMine at all.

Open the Gemfile from the project window and add the following line to it:

  gem 'bourbon'

Now we need to install the Gem by running bundle install. We can do this directly from RubyMine by navigating to Tools | Bundler | Install.

Hit the Install button on the window that shows and the Gem will be installed correctly.

Now we can edit the CSS file that is in the App/Assets folder called species.css.scss. Open this file and add the following CSS code to the file:

@import "bourbon";
p {
  @include linear-gradient(to top, white, steelblue);
}

Reload the page that shows one of the species that you created such as http://localhost:3000/species/1, as shown in the following screenshot. Now isn't that much better?

If you have never debugged a Rails application, RubyMine will detect that you are missing some Gems and ask if you want to install what is necessary to continue debugging. Hit the YES button and RubyMine will begin installing the gems.

Your application will now be ready to initiate a debugging session. The server is already running, but we can set a breakpoint anywhere in the Rails program to inspect what is going on at a deep level.

In the Controllers folder within the app folder, open the file species_controller.rb and set a breakpoint on the line 27. This is done by simply clicking on the line right next to the number 7 like this:

Now we need to get the application to execute this part of the code. Since this is the Create method, it means that we must be in the process of creating a new Species record in our table.

Click on the New Species link in the browser or go to the link http://localhost:3000/species/new.

This brings up the form that allows you to enter the values for the table.

Enter some values such as Human for the name, 5618 for the identification,and check the assimilated checkbox.

Select the Create Species button, RubyMine will be brought to the front window and you will see a screen that looks like the following:

The bottom of the screen is divided into three panels: The stack Frames on the left, the available variables in the middle, and the Watches panel on the right.

The Frames panel lets you look at the various program threads as well as the stack frames for each thread. This can be very useful to determine the context in which your breakpoint was called.

Change the frame and go up to see which method was called before the current method. As you change frames, you will see the variables change along with it, showing you the local variables available in that particular stack frame.

Change the frame back to the create method so that we can continue.

The middle panel is where you can inspect variables as you step through the lines of code.

Select the little arrow next to the params variable in the center panel. It should look similar to the following screenshot:

Select the little arrow next to the species variable that is inside the params variable; you will see the three variables from the HTML form that were sent to the server.

Right-click on the @species variable and select the Add to Watches menu. This variable will now be shown in the Watches panel on the right.

Now move through the code and let's watch this variable change.

There are five buttons that control the execution of the program in the debugger, as shown in the following screenshot:

In order from left to right they are: step over, step into, force step into, step out, and run to cursor. The most used is the step over button which we will click now. Once clicked, notice that the @species instance variable in the Watches window is no longer nil, but has a value.

Open the variable in the Watches window.

Scroll down to find the @attributes variable and open that by clicking on the gray arrow. You will see the various properties of the actual @species object that contains the same values from the params hash that were sent to the form. These were put into place by the Species.new code that we just stepped over.

Notice that the created_at and modified_at properties of this variable are still nil. This is because the new object that we created has not yet been saved.

Click on the line 30 of the previous source file of the debugger windows which has the code: if @species.save.

Click on the debug button Run to Cursor. The program will continue executing until it gets to this line.

Now, press the button to step over and the @species.save command will be executed. If the saving operation worked without error, then the program should now be on the line 31.

Look at the @species variable in the Watches window and you will see that the two date properties will now be filled in with the current date and time.

To continue normal operations, you can hit the green arrow on the left-hand side of the debugging windows and the program will continue to execute.

On the Tools menu, select Run Rails Console and RubyMine will ask you which environment you would like to load into the console. This lets you inspect/change your debug, test, or production environments directly. The default option gives the development environment.

Select OK and the console will open.

The Rails console prompt >> means that it is ready for input from the keyboard.

Type 2 + 2 and hit Return. The result should be 4 as you can see in the following screenshot. This is just like the IRB console, in that you can type Ruby expressions and they will be evaluated interactively.

Let's perform some database lookups using Rails syntax.

The proper syntax for Rails 4.0 is something like the following, which you can type in and see the result:

Species.where(assimilated: true).load

The result will be something like this:

  Species Load (0.2ms)  SELECT "species".* FROM "species" WHERE "species"."assimilated" = 't'
#<ActiveRecord::Relation [#<Species id: 3, name: "Human", identification: 5618, assimilated: true, created_at: "2013-06-03 00:58:57", updated_at: "2013-06-03 00:58:57">]>

Add the following line to your Gemfile:

gem 'minitest-reporters'

Navigate to Tools | Bundler | Install and the Gem will be installed and added to your project.

Expand this folder in the Project window and you will find a file called test_helper.rb.

Open this file and add the following lines to the top of the file:

require 'minitest/reporters'
MiniTest::Reporters.use!

Add the previous lines right below the third line, which should be something like this:

require 'rails/test_help'

Save the file and then expand the Models folder.

Open the file contained inside called species_test.rb, which was automatically generated from the scaffold generators for us.

Replace the following three commented-out lines:

  # test "the truth" do
  #   assert true
  # end

Replace the previous code with the following testing code:

  test 'Full Species Assimilation' do
    @species = species(:not_assimilated)
    assert_equal @species.full_species, "Human 1 has not been assimilated.", 'Full Species Not Assimilated incorrect'

    @species = species(:assimilated)
    assert_equal @species.full_species, "Human 1 has been assimilated.", 'Full Species Assimilated incorrect'
  end

Expand the folder inside the test folder called fixtures.

Open the file contained within called species.yml.

Replace the text in this file with the following code:

assimilated:
  name: Human
  identification: 1
  assimilated: true
  notes: Only partially assimilated

not_assimilated:
  name: El-Aurian
  identification: 1
  assimilated: false
  notes: Guinan's Species

Right-click (ctrl + click on Mac) on the word Species in the following code line in the species_test.rb file in RubyMine.

class SpeciesTest < ActiveSupport::TestCase

This will bring up a menu that will let you run the tests for this module, as shown in the following screenshot:

If everything has gone correctly, you should see tests running in the bottom panels, as shown in the following screenshot:

Open the file from the app folder, the models folder, and the file called species.rb. This looks like a good place to add our model-level method called full_species. That method is written for you in the following step.

Copy and paste the following code into this file, replacing the code that is there:

class Species < ActiveRecord::Base
  def full_species
    "#{name} #{identification} has #{(assimilated? ? '' : 'not')} been assimilated."
  end
end

This is a simple method designed to merely combine some of the database fields into a common sentence that might be used in several Rails views across the application.

Now that we have a method in place, lets re-run the tests as before. This time we can use the configuration pull-down menu at the top of the IDE and just hit the green arrow next to the menu to re-run the same tests. Unfortunately, we still have an error in our code. You will see a long red bar above the testing windows as well as an error message like the following:

MiniTest::Assertion: Full Species Assimilated incorrect.

--- expected

+++ actual

@@ -1 +1 @@

-"Human 1 has been assimilated."

+"Human 1 has been assimilated."

Replace the line in the species.rb model file:

    "#{name} #{identification} has #{(assimilated? ? '' : 'not')} been assimilated."

with this:

    "#{name} #{identification} has#{(assimilated? ? ' ' : ' not ')}been assimilated."

Re-run the tests and we should now see a green bar and all tests passing successfully.

Navigate to VCS | Enable Version Control System...

This will bring up a little window that will let us choose which VCS to use for this particular project. We can have different VCSs for each project that we have in RubyMine, as shown in the following screenshot:

Select OK. This will initiate the Git system and automatically issue the command git init on your project.

Expand some folders. You will see that all of the files are now color coded in red. This means that the files are not yet under version control, so we need to add them to our local Git repository. This takes two steps: Adding the files and committing the files.

To add the entire project, click on the frame panel button at the bottom of the project called 9: Changes.

Click on the link Click to Browse which is next to Unversioned Files. A new window will open with a list of files in the project.

Select the top-level folder and hit the green + button on the left of this window. This will add all of the files and folders to the project under the Git staging system. As shown in the following screenshot, the project window will now show all the files with a green color, which means the files are added to the local Git repository, but they have not yet been committed:

Right-click on the project folder in the project list and navigate to Git | Commit Folder. This will bring up a window like the following:

From this window, we can select many options, but the most important is to add a comment in the bottom text box. This comment will follow this commit forever.

Type Initial Project Commit in this box.

Hit the button Commit in the bottom-right corner. This will add the files to the Git repository and we can now see that all the files have returned to a black color in the project window. This means that all the files are now under version control. If we make a change to a file, the color will change appropriately. From now on, we can add single files and commit them either individually or as a group, just like the initial commit.

Add the following comment line to our species.rb file from app | models above the method that we created earlier:

# Return a status string of a particular species

Save the file.

Right-click on the opened file and navigate to Git | Compare with Latest Repository Version. This will show us a window with both versions of the file shown next to each other with insertion and deletions from both versions to show exactly what is different between the two files, as you can see in the following screenshot:

Open the helloworld.rb file from the project window on the left. We will need to fix a bug in the code first and then we will refactor some of the code into a method that we can reuse later.

On the line 24 change the following:

    51.times do |idx|

Change the preceding line to the following:

    num_lines.times do |idx|

Select the following entire block of code using your mouse:

  pdf.stroke do
    num_lines.times do |idx|
      pdf.line([0, idx*grid], [size, idx*grid])
      pdf.line([idx*grid, 0], [idx*grid, size])
    end
  end

Click on the Refactor This menu item from Refactor. This will bring up a menu like the following:

Select #6 Method… and a window will be shown that will let us choose the method name and order of parameters that will be passed to the method, as shown in the following screenshot. RubyMine automatically determines which parameters are needed to complete the code.

Enter the method name draw_grid.

Hit OK.

RubyMine will now create a method with the selected code and insert a call to the new method draw_grid. The method is placed at the top of the code and should look like the following code:

def draw_grid(grid, num_lines, pdf, size)
  pdf.stroke do
    num_lines.times do |idx|
      pdf.line([0, idx*grid], [size, idx*grid])
      pdf.line([idx*grid, 0], [idx*grid, size])
    end
  end
end

The method call then looks like the following:

  draw_grid(grid, num_lines, pdf, size)

Now lets try renaming a variable. Click on one of the variables named num_lines.

Right-click and navigate to Refactor | Rename.

Begin typing a new name for this variable, number_of_lines.

Notice that the variables throughout the file are changed as you type.

Open this Gemfile and add the following line:

gem 'simplecov', :require => false, :group => :test

Navigate to Tools | Bunder | Install.

Open the test/fixtures/species.yml file and add back the following fixtures:

one:
  name: MyString
  identification: 1
  assimilated: false

two:
  name: MyString
  identification: 1
  assimilated: false

Rerun the test with the coverage option and all of our tests should pass. A new panel will open on the right that has the results of our coverage, as shown in the following screenshot:

Click on the Generate Coverage Report icon which looks like a square with a green arrow point up.

The next window will ask you where you want to save the file and gives the option of opening the resulting report in your browser.

Select this option and hit Save.

Your browser should now open with a report in which you can click on each line and get actual details of which lines of code have not been tested or executed:

Click on the file app/controllers/species_controller.rb.

You will then get a screen like the following, which shows much more detail about exactly which lines were not tested.

The lines in green are tested and they show a little number on the right in a black circle that tells how many times that line of code was executed during the tests. The light red lines show which code has not been executed at all and are ripe for a new test to be written, so we can aspire to 100 percent code coverage:

Now you, the new RubyMine drone, can begin to write the missing tests and continue until you are a perfect 100 percent code coverage expert.

Click on the Database button on the left side of the RubyMine main frame. This will open a panel that looks like the following:

Click on the panel and then use the command code as described in the window. (This will be different for each operating system).

Select the menu item Import from sources … and then hit OK from the next window.

Click on the table that shows and open up each level.

Double-click on the id element of the Species table and we will see a window like the following:

This allows us to view, add, modify, and delete records from our tables easily.

Click on the + icon, we will then be able to manually add another record to our database.

If we double-click on one of the cells, we can modify the values that are stored in the database. This is a quick way to edit some mistakes that we made when entering data or to test out a part of our interface. Let's add another record via the table editor.

Click on the + icon and enter the following information into the cells of the new blank row that is created:

Now we have two species in our database. We can edit these items as we please, but please note that updates do not automatically change the updated_at field. This is done through the Rails system as it saves a record and we are bypassing that framework completely using this system. We are talking directly to the database.

RubyMine also gives us a nice interface to perform direct database queries on our data tables directly.

Open the database console by hitting the icon Database Console at the top of the Database panel. This opens a window in the main editor panel that lets us type SQL queries directly and execute them to get a dataset back, as you can see in the following screenshot:

Type the following in the console window:

select * from species where assimilated = 'f'

Select the green arrow button right above the text in the editor panel. Don't select the green arrow which runs a specific configuration.

The results of this direct query will now show at the bottom in a new panel with a database table editor like we had before. It will look something like the following screenshot:

We selected all of the species in our table that have not yet been assimilated. We can now remedy that easily.

Double click on the f letter in the assimilated column.

Change that to t.

Navigate to VCS | Import into Version Control | Share Project on GitHub.

This will bring up a window asking for your GitHub account and giving you the opportunity to create one if you don't have one, as you can see in the following screenshot. GitHub is free if you keep your project public and open source, but they also have paid options if that is unappealing to you.

After you log in with a valid account, the next window that appears will be for you to name your project and give it a short description. Doing this will create the remote repository on GitHub for us to use later.

If we now log in to the GitHub account and navigate to your project, you can copy the Git repository URL, as you can see in the following screenshot, which we can add to our deploy.rb file for use in Capistrano:

Now, we need to install the Capistrano Gem by adding it to our Gemfile as we have done before, except this time Rails knows that this is a common Gem, so we just need to uncomment out the line in the Gemfile like the following:

# Use Capistrano for deployment
 gem 'capistrano', group: :development

Navigate to Tools | Bundle | Install.

Now we can use RubyMine tools to start the Capistrano process. We must first navigate to Tools | Capistrano | Capify Application.

This will create two files: Capfile and config/deploy.rb.

Open the Capfile file and uncomment out the following line so that the process will run the precompilation of the assets pipeline after deploying the files to your webserver:

load 'deploy/assets'

Open the config/deploy.rb file and edit the following lines using the GitHub repository URL that you copied from your account for the :repository line:

require 'capistrano-deploy'

set :application, "progeny"
set :repository, "https://github.com/lockersoft/Progeny.git"
set :user, "lockersoft"

Of course, you would use your own specific information for the server where you are going to deploy your application. There are many different options that you can use from Capistrano to customize your deployment to meet a variety of needs for your particular collective. Too many to show here, so start by looking at the Capistrano Gem documentation found at https://github.com/capistrano/capistrano.

Once we have our deploy.rb file the way we want it, we can commit our changes and push those changes to the GitHub remote repository that we created earlier. Navigate to VCS | Commit Changes.

This will bring up a window that we saw earlier where we can add a message to our commit. At the bottom of the window, instead of selecting Commit, we want to select the option Commit and Push...:

This will bring one final window which allows us to choose a different branch. Just hit the Push button and our project will be uploaded to the GitHub repository.

Now, we are ready to deploy the project. We will let Capistrano do that for us by merely running that script. Navigate to Tools | Capistrano | Run Capistrano, which will bring a window to allow us to select one of many tasks to run. The first one we want to run is the deploy:setup command. This runs much like the rake tasks and once we select and run a task, it is saved in our task configuration menu at the top of the main project for later use, as shown in the following screenshot:

This will create the directory structure that Capistrano needs on your remote server for us.

The next Capistrano command is selected from the same menu, but it is simply deploy. This will actually issue a command on the remote server to clone our Git repository from GitHub into our remote server directory and we will now be ready to access our server.

If everything is right in our deploy.rb script, which is saying a lot, then the Rails server will be running on our remote server and we can simply connect to the server via a browser like one of our users would.