Day: June 29, 2011

Installing rails 3.1 and ruby 1.9.2-p180 using rvm and unicorn setup

Install rvm

Open your .bashrc file.
And replace the following line
[ -z “$PS1” ] && return
with
if [[ -n “$PS1” ]]; then
Now add this to the last line of the file
if [[ -s $HOME/.rvm/scripts/rvm ]] ; then source $HOME/.rvm/scripts/rvm ; fi

fi
This loads RVM into a shell session.

If already have rvm then
Update rvm

$ rvm get latest

if this shows error like ‘downloaded does not match it’s md5 checksum’

then run

$ rvm get head
$ rvm reload
$ rvm get latest

For ruby 1.9.2 we want the packages it lists under the MRI & ree section. Let’s install those now.

$ sudo aptitude install build-essential bison openssl libreadline5 libreadline-dev curl git-core zlib1g zlib1g-dev libssl-dev vim libsqlite3-0 libsqlite3-dev sqlite3 libreadline-dev libxml2-dev git-core subversion autoconf

Setting up Ruby

Do rvm list known to know all ‘Ruby implementation made available through RVM’

$ rvm list known

Then install latest stable release of ruby

$ rvm install 1.9.2

You can see the ruby versions installed and currently using ruby version by

$ rvm list rubies

To list default ruby

$ rvm list default

You can change it by

$ rvm use ruby-1.9.2-p180

for default : rvm –default 1.9.2-p180

Using Gemsets

Install rails stable release and then rails 3.1
Start by creating our gemsets

$ rvm gemset create rails307 rails31

See available gem sets by

$ rvm gemset list

If any confusion with rails31 gemset delete it

$ rvm gemset delete rails31

And create rails31rc

$ rvm gemset create rails31rc

As a best practice, remember to always use one gemset per project*.

Installing Rails

Now we have multiple gem set installed. Now set the different gem set for ruby versions.

$ rvm use 1.9.2-p180@rails307

Install Rails 3.0.7

$ gem install rails [-v 3.0.7] [–no-rdoc]

Select the gemset for Rails 3.1

$ rvm use 1.9.2-p180@rails31rc

for default $ rvm use 1.9.2-p180@rails31rc –default

Install Rails 3.1

$ gem install rails -v “>=3.1.0rc”

if not found

$ gem install rails -v “>=3.1.0.rc4”

rvmrc file

Switching from one project to another, from a client to a personal project, from testing the release candidate to developing using the latest stable version, always having to manually switch from using a gemset to another can impact productivity. The project .rvmrc files can increase the development speed by setting up our project’s ruby environment when we switch to the project root directory.

The rule of thumb here is to use a .rvmrc file for each project, for both development and deployment.*

.rvmrc file :

rvm –rvmrc use 1.9.2-p180@rails31rc

if you go to your app folder ‘$ cd myapp’ then you can see like





There are three types of .rvmrc files
1) system : on /etc/rvmrc
2) user : $HOME/.rvmrc
3) Project : .rvmrc

Create a new rails App

$ rails new myapp

with mysql as database

$ rails new myapp -d mysql
$ rails server -p4000

If u get error like

“”” home/user/.rvm/gems/ruby-1.9.2-p180@rails31rc4/gems/execjs-1.1.2/lib/
execjs/runtimes.rb:43:in `autodetect’: Could not find a JavaScript
runtime. See https://github.com/sstephenson/execjs for a list of
available runtimes. (ExecJS::RuntimeUnavailable) “””

Then you need a javascript engine to run your code…

try installing rubyracer (Embeds the V8 Javascript interpreter into Ruby.)

in your Gemfile add

gem ‘therubyracer’
and do bundle install

Unicorn Installation

$ rvm use default # Just to make sure
$ gem install unicorn

Start unicorn server

$ unicorn_rails

A Program for finding all files in a nested folder that contains a specific string : Ruby Vs Python

This program has a major method ‘search in file’ that accepts a folder path as a parameter. Next initialize whatever variables we want.

Ruby
Python

def search_in_file(folder_path)
      @file_array = Array.new
      files_has_string = Array.new
      erb_files_has_no_string = Array.new
      rb_files_has_no_string = Array.new
      unknown_files = Array.new
      iterate_through_dir(folder_path, @file_array)
      ———
      ———

import os
import re
file_array = []
def search_in_file(folder_path):
      files_has_string = []
      erb_files_no_string = []
      rb_files_no_string = []
      unknown_files = []
      iterate_through_dir(folder_path)
      ———
      ———

Then calls a method ‘iterate_through_dir’ which has two parameters in ruby and one in python, ‘folder path’ and instance variable ‘file_array’. In python we initialized a gobal variable ‘file_array’. But in ruby ‘@file_array’ is an instance variable. This method finds file paths of files included in the folder we have given, say ‘sample_folder’. Using the class method ‘glob’ in ruby and os module’s listdir in python we can find all the files and folders that inside sample_folder. Next check it is a file or a folder. If it is a folder we need to iterate through that folder(use recursion ) and get the file paths of files inside the folder. Else it is a file push that file path into our instance array ‘file_array’.

Ruby
Python

def iterate_through_dir(dir_path, file_array)
      file_paths = Dir.glob(dir_path + “/*”)
      file_paths.each do |f|
         if File.file?(f)
            file_array.push(f)
         else
            iterate_through_dir(f, file_array)
         end
      end
end

def iterate_through_dir(dir_path):
      file_paths = os.listdir(dir_path)
      for i in file_paths:
         path_to_dir = dir_path + “/” + i
         if os.path.isdir(path_to_dir) == True:
            iterate_through_dir(path_to_dir)
         else:
            file_array.append(path_to_dir)

Now we got all the file paths of files inside the nested folder sample_folder in @file_array / file_array. Take each element in the @file_array / file_array, and open that file in read mode. Call ‘f.read’ in ruby and ‘f.read()’ in python to get the file contents as a string.

Ruby
Python

      ———
      @file_array.each do |file_path|
      f = File.open(file_path, ‘r’)
      file_contents_in_string = f.read
      ———
      ———

      ———
      for i in file_array:
      f = open(i, ‘r’)
      file_content = f.read()
      ———
      ———

Then call ruby-‘.match’, python – ‘re.search'(import regular expression module first -import re) on file content string to find the string inside the file. If you find the string then put it in an array. If you can’t find then put it in an another array. Before that find the file extensions to get the different type of files and append that file paths to different arrays.

Ruby
Python

———
   if (file_contents_in_string[0..500].match(“your string”))
      files_has_string << file_path
      else
        file_extension = File.basename(file_path).split(‘.’)[1]
        if file_extension == ‘rb’
           rb_files_has_no_string << file_path
        elsif file_extension == ‘erb’
           erb_files_has_no_string << file_path
        else
           unknown_files << file_path
      end
end
end

———
   if re.search(‘find_this_string’, file_content[0:500]):
      files_has_string.append(i)
      else:
       &  file_extension = os.path.basename(i).split(‘.’)[1]
       & if if file_extension == ‘rb’:
           rb_files_no_string.append(i)

        elif file_extension == ‘erb’:
         erb_files_no_string.append(i)
      else:
           unknown_files.append(i)

At last call the print_results method to print results.

Ruby
Python

——–
      print_results(@file_array, rb_files_has_no_string, erb_files_has_no_string, unknown_files)
end

print search_in_file(“/your/path/to/nested/folder”)

——–
      print_results(rb_files_no_string, erb_files_no_string, unknown_files)

print search_in_file(“/your/path/to/nested/folder”)

Output : Ruby

Output : Python

search_a_string
The method ‘print_results’ accepts four arrays and prints the results accordingly.