Ruby on Rails Tutorials

Merging branches on two different remotes GIT

2014-11-15T03:38:00.000+05:30

Steps to merge branches located on two different remotes.

In this example lets consider we have a repo on both and Github & BitBucket :

Step 1: Clone the repo which you want finally to hold all the changes.

I will choose Github

git clone <repo URL>

Step 2: Add remote for Bitbucket or other repo into the cloned repo

git remote add origin_bitbucket <url>

Step 3: Checkout the branch from Bit Bucket remote

git checkout origin_bitbucket/<branch name>

Step 4: Check out the branch you want to merge into

git checkout origin/master

Step 5: Merge BitBucket branch into it

git merge origin_bitbucket/<branch name>

Git fatal reference error on deployment or submodule update

2014-06-08T09:53:00.001+05:30

Sometimes we face this issue with GIT

fatal: reference is not a tree: d80ee5f27b06e84d40a7d2758525b682aaba7d72

This is because the module has not been pushed to the main repo or the branch has not been pulled on the machine the command is being executed.

Branch issues

git checkout master
git fetch origin

Submodule issues

git submodule update

Best Jenkins Plugins I use !

2014-06-08T09:45:00.002+05:30

1. Compress Artifacts Plugin

Keeps build artifacts compressed to save disk space on the master.

2. Copy To Slave Plugin

This plugin allows copying files located somewhere on the master node into the jobs' workspaces, whether their builds take place on the master node or on slave nodes.

3. Cucumber Reports Plugin

This plugin creates pretty cucumber-jvm html reports on jenkins

4. Delete log

This plugin add action delete log to build page. If the build is build of matrix job, the action delete log for all its configurations too.

5. Green Balls

Because green is better than blue! For color blind support configure user property.

6. HTML Publisher plugin

This plugin publishes HTML reports.

7. Jenkins disk-usage plugin

This plugin counts disk usage.

8. Jenkins Gravatar plugin

This plugin shows Gravatar avatar images for Jenkins users.

9. Timestamper

Adds timestamps to the Console Output.

10. embeddable-build-status

This plugin adds the embeddable build status badge to Jenkins so that you can easily hyperlink/show your build status from elsewhere.

Using Frank with Rubymotion

2014-06-08T09:05:00.000+05:30

Writing acceptance tests for iOS application in Rubymotion

Steps involved

1) Add the motion-frank gem to the Gemfile
2) Run the initializer rake frank:init_features

3) Now you have the features directory.

4) Write a sample test

eg:

Feature: Navigating around the app / smoke test
As a user
I want to be able to get to all parts of the app
So I can use it and not get confused or lost

Background:
Given I launch the app
Given I am on the search Screen with empty search

Scenario: Search
Given I am on the search screen
Then I should see a navigation bar with label text "Search"
When I fill in a search term
Then I should see a navigation bar with label text "Results"

5) Save this as a xyz.feature file

6) Run rake frank to see this test fail

7) Add the step definition file in the features/step_definitions named something like xyz_steps.rb

8) Add step methods describing the steps and what should happen on the simulator to match the test.

eg.

Given(/^I am on the search Screen with empty search$/) do
wait_for_element_to_exist_and_then_touch_it("textField placeholder:'Search by name'")
end

Given(/^I am on the search screen$/) do
check_element_exists("textField placeholder:'Search by name'")
end

and go on ....

Go through the sameple steps and implementation in the frank-cucumber library to get hold of more methods to test the UI.

Also you can use rake frank:symbiote to get the list of UI elements accessible for testing in a simulator.

Run "rake frank:symbiote" in the Rubymotion directory and once the simulator is up with the application open the browser and navigate to "localhost:37265"

Quick Tips :

1) For ruby code which like occurs in multiple step file , write ruby files in the support folder such as

def check_search_bar
check_element_exists("textField placeholder:'Search by name'")
end

Now you can use this check_search_bar method in any step definition file & reduce the amount of code you write to get your code working.

Happy Testing with cucumber !! Its fun.

Starting With Rubymotion

2013-04-30T03:22:00.000+05:30

Rubymotion

RubyMotion is a revolutionary toolchain for iOS.
It lets you quickly develop and test native iOS applications for iPhone or iPad, all using the awesome Ruby language you know and love.

To start with Rubymotion we would need

A Mac
Ruby
xCode
Command Line Build Tools
Rubymotion
Text editor
Little knowledge of the Cocoa API's
Faith, Hope and Goodwill

Assumming that the setup is done without any issues, Lets start

Check for an update for the Rubymotion installer

sudo motion update

Creating our first application

motion create RssReader

Structure of the Rubymotion application

Explaining the structure of the application

app_delegate.rb : Entry point of an iOS application
Default-568h@2x.png : Default Splash Screen for iPhone5
main_spec.rb sd: Main spec file
Rakefile : Application configuration

Running the application on the Simulator

rake

So this is the first very basic application which we have put up and running on a simulator.

I will be moving step by step from the basics of using Ruby alongwith Cocoa and creating a Demo application throught it.

TCS RSS Feed Reader 123

2013-03-29T23:49:00.001+05:30

TCS RSS Feed
This is an iOS application build using

Running on Simulator/Device

You will need Rubymotion installed on your Mac.

Clone repo git clone git@github.com:upadhyay-ashish/TCSRssReader.git
Bundle gems bundle install
Setup cocoapods pod setup
Setup Developer license reference in the Rakefile
To run on simulator rake else to run on a Device rake device
To create a distribution IPA rake archive:distribution

Replacing master with a branch GIT

2013-02-25T17:16:00.002+05:30

This will help us to overwrite the master branch with a new branch incase the new branch is in a better state than the master

git checkout seotweaks

git merge -s ours master

git checkout master

git merge seotweaks

Thanks

Using Oracle JDBC with JRuby on Mac OSx

2013-01-08T20:57:00.003+05:30

Please follow the below steps to create a jruby library to connect to any oracle database on Mac OS x using Java ODBC drivers.

STEP 1: Create the Library folder and the Ruby file. eg Sample.rb
Step 2 : Add Gemfile to enable using jruby to connect to the database

Step 3 : add the following gems to the Gemfile

gem 'activerecord'
gem "activerecord-jdbc-adapter"

Step 4 : In the ruby file Sample.rb here please use the following lines and then write appropriate code to access the data.

class Person < ActiveRecord::Base

    establish_connection(
      :adapter => 'jdbc',
      :driver   => 'oracle.jdbc.driver.OracleDriver',
      :url      => 'jdbc:oracle:thin:@server:port/sid',
      :username => 'ors',
      :password => 'ors'
      )

      self.table_name = :table_name_here

        def self.all

          connection.select_all <<-SQL
                  select * from table_name_here
             SQL
        end
end

Step 5 : Go to terminal , run

bundle install

jruby Sample.rb

Step 6 : If there is a driver not found error please download the driver from oracle site here
and place it in /Library/Java/Extensions/ on your mac.

Have Fun !

Using nested_forms gem + dropbox-paperclip + twitter-bootstrap

2012-12-08T13:38:00.002+05:30

This is a tutorial about using nested_forms gem with dropbox-paperclip plugin on Heroku to create a multiple photo upload albums interface with twitter bootstrap

Demo application :

http://ashish-albums.herokuapp.com/

Gems used :

Step 1 : Create a new rails app and add the gems to Gemfile.

paperclip

paperclip-dropbox

nested_form

Step 2 : Create 3 models

rails g model User name:string

rails g model Album name:string user_id:integer

rails g model Photo tags_name:string album_id:integer

Step 3 : Adding relationships among models

in app/models/user.rb :

has_many :albums, :dependent => :destroy
accepts_nested_attributes_for :albums
attr_accessible :name, :albums_attributes
validates_presence_of :name

in app/models/album.rb

belongs_to :user
has_many :photos, :dependent => :destroy
accepts_nested_attributes_for :photos, :allow_destroy => true
attr_accessible :name, :photos_attributes
validates_presence_of :name

in app/models/photo.rb

belongs_to :album
attr_accessible :avatar, :tags_name
has_attached_file :avatar,
:storage => :dropbox,
:dropbox_credentials => "#{Rails.root}/config/dropbox.yml",
:styles => { :thumb => "100x100" },
:dropbox_options => {
:path => proc { |style| "#{style}/#{id}_#{avatar.original_filename}"}
}
validates_presence_of :avatar

Step 4 : Adding a controller and a few actions

rails g controller Users
add following code to the controller
def index
    @users = User.all
end

def new
    @user = User.new
end

def create
    @user = User.new(params[:user])
     if @user.save
        redirect_to root_url
else
      redirect_to root_url
    end
end

def show_albums
    @albums = Album.find(params[:id])
end

def destroy
@user = User.find(params[:id])
@user.destroy
   redirect_to root_url
end

Step 5 : Adding routes to routes.rb

resources :users do
    member do
      get 'show_albums'
    end
end
root :to => 'users#index'

Step 6 : Creating views for forms and data show

index.html.erb

new.html.erb

show_albums.html.erb

_album_fields.html.erb

_photo_fields.html.erb

Step 7 : Adding form html to views

in index.html.erb :

<%= link_to 'New User', new_user_path , :class => 'btn btn-medium btn-primary pull-right'%>
<table class="table table-striped">
<tr>
    <th>Name</th>
    <th>Album Names</th>
    
    <th>Destroy</th>
</tr>
<% @users.each do |user| %>
<tr>
    <td><%= user.name %></td>
    <td>
      <% (user_albums_link user).each do |album_link| %>
        <%= album_link.html_safe %>
      <% end %>
     <% thumbnails = show_photo_thumbnails(user.albums) if user.albums %>
     <% if thumbnails %>
        <% thumbnails.each do |thumb| %>
          <%= thumb.html_safe %>
        <% end %>
     <% end %>
    </td>
    
    <td>
        <%= link_to t('.destroy', :default => t("helpers.links.destroy")),
                      user_path(user),
                      :method => :delete,
                      :data => { :confirm => t('.confirm', :default => t("helpers.links.confirm", :default => 'Are you sure?')) },
                      :class => 'btn btn-mini btn-danger' %>
    </td>
</tr>
<% end %>
</table>
<br />

in new.html.erb :

<%= nested_form_for @user, :html => { :multipart => true } do |f| %>
<div class="controls">
Username :
<%= f.text_field :name, :class => 'text_field' %>
</div>
<%= f.fields_for :albums %>
<%= f.link_to_add "Add an album", :albums %>
<br />
<br />
<div class="controls">
<%= f.submit nil, :class => 'btn btn-primary' %>
</div>
<% end %>

in _album_fields.html.erb :

<div class="controls">
Album Name :
<%= f.text_field :name, :class => 'text_field' %>
<%= f.link_to_remove "Remove this album" %>
<%= f.fields_for :photos %>
    <p>
    <%= f.link_to_add "Add a photo", :photos %>
    </p>
</div>

in _photo_fields.html.erb :

<div class="controls offset1">
File :
<%= f.text_field :tags_name %>
<%= f.file_field :avatar %>
<%= f.link_to_remove "Remove this photo" %>
</div>

in show_albums.html.erb :

<% thumbnails = get_photos(@albums) if @albums %>
<% if thumbnails %>
    <% thumbnails.each do |thumb| %>
      <%= thumb.html_safe %>
    <% end %>
<% end %>
<%= show_tags @albums %>

Step 8 : Add dropbox.yml in config folder with following data :

app_key: <%= ENV["DROPBOX_APP_KEY"] %>
app_secret: <%= ENV["DROPBOX_APP_SECRET"] %>
access_token: <%= ENV["DROPBOX_ACCESS_TOKEN"] %>
access_token_secret: <%= ENV["DROPBOX_ACCESS_TOKEN_SECRET"] %>
user_id: <%= ENV["DROPBOX_USER_ID"] %>

These variables are Environment variables in environments files.

For detailed setup for paperclip-dropbox gem visit

https://github.com/janko-m/paperclip-dropbox

Step 9 : Setup Twitter Bootstrap

rails generate bootstrap:install less
rails g bootstrap:layout application fixed

Step 10 : Run the application :

bundle
rake db:create
rake db:migrate
rails s

-----------------------------------------------------------------------------------------------------------------------Thanks

Cloning a specific GIT branch from a repository

2012-10-22T13:45:00.000+05:30

Step 1 : Clone the master branch

git clone <repo master>

Step 2 : Clone the specific GIT branch

git fetch origin +branchname:branchname

Step 3 : Switch to the branch

git checkout branchname

Step 4 : Check the file difference between the master and the branch

git diff --name-status master..sibos

Migrating code from SVN to GIT

2012-09-28T00:29:00.000+05:30

Install git-svn on ubuntu or linux

Simple command to begin with

$ git-svn clone <svn repo link> --no-metadata -s my_project

You need to do a bit of post-import cleanup. For one thing, you should clean up the weird references that git svn set up. First you’ll move the tags so they’re actual tags rather than strange remote branches, and then you’ll move the rest of the branches so they’re local.

To move the tags to be proper Git tags, run

$ cp -Rf .git/refs/remotes/tags/* .git/refs/tags/
$ rm -Rf .git/refs/remotes/tags

This takes the references that were remote branches that started with tag/ and makes them real (lightweight) tags.

Next, move the rest of the references under refs/remotes to be local branches:

$ cp -Rf .git/refs/remotes/* .git/refs/heads/
$ rm -Rf .git/refs/remotes

Now all the old branches are real Git branches and all the old tags are real Git tags. The last thing to do is add your new Git server as a remote and push to it. Here is an example of adding your server as a remote:

$ git remote add origin git@my-git-server:myrepository.git

Because you want all your branches and tags to go up, you can now run this:

$ git push origin --all

Fix Readline error Ubuntu

2012-08-11T00:46:00.000+05:30

Fix readline error with Ruby

sudo apt-get install libreadline-dev

cd ~/.rvm/src/ruby-1.8.7-p249/ext/readline

ruby extconf.rb && make && make install

Thanks

Capistrano + GIT : Too many arguments while deployment

2012-08-10T17:26:00.002+05:30

Issue : shell command failed with return code 33024

It's a ruby + git clone + windows issue.

If I chain commands with && while calling system(cmd) from ruby, chaining "git clone" with other commands is not fine. Git clone perceives the chained commands as its own continuation, i.e. as a destination directory, unless I run it from the command line.

As I couldn't find any references or solutions to this problem on the internet, I put a hack to capistrano code, so "git clone" is executed separately.

In <ruby directory>\lib\ruby\gems\1.8\gems\capistrano-2.5.18\lib\capistrano\recipes\deploy\strategy\base.rb after the line 53 (cmd = cmd.split...)
add the following lines:

if cmd =~ /\s\&\&\s/ && cmd =~ /^git\s+clone/
cmd1, cmd = cmd.split(" && ", 2)
super(cmd1)
end

it checks if it's a chained command and the first command is "git clone", and if such it executes it separately. It may not work for all possible cases.

Also you can try using ubuntu from your local.

Installing RMagick with Imagemagic on Windows 7/Vista

2012-08-09T13:58:00.000+05:30

From : https://github.com/rmagick/rmagick/issues/27
Thanks to : https://github.com/wingfire

Working with Windows 7 64bit and Ruby 1.9.3.

1. Install Ghostscript
http://downloads.sourceforge.net/project/ghostscript/GPL%20Ghostscript/9.05/gs905w32.exe

2. Install Imagemagick
Use the 32 bit version, 64bit is not working.
http://www.imagemagick.org/download/binaries/ImageMagick-6.7.6-1-Q16-windows-dll.exe (2012-03-22)
Install dev headers (Check!)
Install into C:\opt\

3. Restart the console/cmd prompt/IDE/.. or just restart windows to make Imagemagick commands available

4. Install rmagick
gem install rmagick --platform=ruby -- --with-opt-lib=C:/opt/ImageMagick-6.7.6-Q16/lib --with-opt-include=c:/opt/ImageMagick-6.7.6-Q16/include

Installing Ruby on Mac OS

2012-06-13T19:56:00.000+05:30

STEP 1 Installing XCode

Please install XCode + Developer Tools from the App Center.
XCode is needed to install the Developer tools used in compilation of the Ruby packages for installation on the system.

STEP 2 Install RVM

Install RVM using the command

curl -L get.rvm.io | bash -s stable

This will install RVM on your system.
Please close and open the terminal again to load RVM.
To verify the RVM installation , open Terminal and type

rvm requirements

This will show a help doc.

Step 3 Installing required RVM packages before installing Ruby

Open Terminal and run the below mentioned commands one after the another

rvm pkg install zlib
rvm pkg install openssl
rvm pkg install iconv
rvm pkg install readline
rvm pkg install autoconf

Step 4 Installing Ruby

Open the Terminal and type the following command

rvm install 1.8.7 --with-gcc=clang

Here 1.8.7 reflects the Ruby version 1.8.7 and the latest patch, so to install any specific version or path you specify it by altering the above mentioned command eg.

rvm install 1.8.7-p334 --with-gcc=clang
rvm install 1.9.3 -C --with-gcc=clang

Step 5 Verify the installation

Open a new Terminal window and type

rvm list This will display the list of the different rubies installed on the system.
To use a specific Ruby version use the following command
rvm use 1.8.7
rvm use 1.8.7-p334
rvm use 1.9.3 To make a Ruby version default for the system use the command
rvm alias create default 1.8.7
rvm alias create default 1.8.7-p334
rvm alias create default 1.9.3

This Ruby version will be the default version of Ruby on the system , to change to other versions of Ruby use the above mentioned commands.
To use default incase of switching use

rvm use default

To remove RVM from the system use the command

rvm implode

Installing Ruby on Ubuntu

2012-06-13T19:54:00.000+05:30

Step 1 Verifying

Verify the system is update and then run a sudo apt-get update on the terminal.

Step 2 Installing RVM on Ubuntu

Open terminal and type

curl https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer | bash -s stable

This will install RVM on your system.
Please close and open the terminal again to load RVM.
To verify the RVM installation , open Terminal and type

rvm requirements

This will show a help doc.

Step 3 Installing required RVM packages before installing Ruby

Open Terminal and run the below mentioned commands one after the another

rvm pkg install zlib
rvm pkg install openssl
rvm pkg install iconv
rvm pkg install readline
rvm pkg install autoconf

Step 4 Installing Ruby

Open the Terminal and type the following command

rvm install 1.8.7 -C --with-openssl-dir=$rvm_path/usr --with-zlib-dir=$rvm_path/usr

Here 1.8.7 reflects the Ruby version 1.8.7 and the latest patch, so to install any specific version or path you specify it by altering the above mentioned command eg.

rvm install 1.8.7-p334 -C --with-openssl-dir=$rvm_path/usr --with-zlib-dir=$rvm_path/usr
rvm install 1.9.3 -C --with-openssl-dir=$rvm_path/usr --with-zlib-dir=$rvm_path/usr

Step 5 Verify the installation

Open a new Terminal window and type

rvm list This will display the list of the different rubies installed on the system.
To use a specific Ruby version use the following command
rvm use 1.8.7
rvm use 1.8.7-p334
rvm use 1.9.3 To make a Ruby version default for the system use the command
rvm alias create default 1.8.7
rvm alias create default 1.8.7-p334
rvm alias create default 1.9.3

This Ruby version will be the default version of Ruby on the system , to change to other versions of Ruby use the above mentioned commands.
To use default incase of switching use

rvm use default

To remove RVM from the system use the command

rvm implode

Installing Ruby on Windows

2012-06-13T19:49:00.000+05:30

Step 1 :

Download Ruby from http://www.ruby-lang.org/en/.

Versions Available :

Ruby 1.8.6
Ruby 1.8.7
Ruby 1.9.1
Ruby 1.9.2
Ruby 1.9.3 *Recommended

Run the installer to install Ruby like any other windows application.
After install verify the installation by opening the command prompt
( Win Key + R : Type CMD : Press Enter )

Type

ruby -v

This should display the Ruby version which has been installed

Step 2

Download Devkit from http://rubyinstaller.org/downloads/archives/

Extract the Devkit in a directory.
Open command prompt and navigate to the the directory where you extracted Devkit.
Type

ruby dk.rb init
ruby dk.rb install
Now Devkit is configured on your system.

Step 3

Download Mysql/any other DB installer and install it on the machine to be used as a database for your Rails application

Creating a native iOS application !

2012-06-13T19:45:00.001+05:30

Step 1 Installing XCode on the system

Download and install XCode from the App Center alongwith the Developer Tools

Step 2 Download the Phonegap SDK

Download and unzip the Phonegap SDK.
Now navigate to the iOS directory in the extracted source and run the Cordova-1.7.0.dmg and install it.

Step 3 Creating a XCode Project

Run XCode and create a new Project

Select the template

Cordova-based Application

This will create the a new project and include the neccesary Phonegap API Files.

Step 4 Changing the default compiler

Click on the application name and select BUILD SETTINGS tab in the center pane
Change the compiler in the BUILD OPTIONS from APPLE LLVM COMPILER to LLVM GCC

Step 5 Build and Run the Project

Click on the left top of the XCode window selecting the default device as iPad/iPhone Now run the Project. This would invoke the simulator and run the application on it.
Once the application runs a error will Popup stating the index.html is not found. Close the simulator and return back to the XCode project window.

Step 6 Include `www` folder in the project to start with application development

Right click the project name and select Show in Finder
Drag the www folder from the Finder to the Project
A window pop's up , select to create references to the files.

Step 7 Again `BUILD & RUN`

Now again build and run the project in an iPad/iPhone simulatore
This time it would show up the index.html which is located in the www folder. Also it would show up the Dialog stating that Phonegap was successfully integrated in the application

Step 8 Download JQuery Mobile bundle

Download the latest build of JQuery Mobile from http://jquerymobile.com/ Unzip the contents and add the files in the www folder categorizing the folders as

javascripts
stylesheets
`images'

Step 9 Including the JQuery mobile in the application

Open index.html and create references to the javascript and css files located in the www folder using the html tags

Step 10

Add a few lines of HTML to the index page and use the JQuery classes and the Phonegap api function calls to implement the features of the native application as desired

Step 11 * not tested though

Once the application is complete or for on Device testing a Apple's Developer License is required to sign the applications.
After signing it , push the application to PhoneGap Build https://build.phonegap.com/.
Download the build package and deploy to th Device.

Setting up RHODES with an Android Emulator

2012-02-11T16:32:00.000+05:30

Setting up the system

1. Installing Ruby. Please follow the sequence of commands given below to install ruby on ubuntu using RVM.

$ sudo apt-get install git
$ sudo apt-get install curl
$ bash -s stable < <(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer)
$ rvm pkg install zlib
$ rvm pkg install openssl
$ rvm install ruby-1.8.7-p334
$ rvm alias create default ruby-1.8.7-p334

2. Download Android-sdk for linux

Android SDK Download

3. Download Android-ndk for linux

Android NDK Download

4. Extract both the zip files in two different folder's.

5. Java is needed to be installed in the system.If not then download the Java SDK zip files from

Java SDK 7 Download

6. Open the terminal and install the rhodes gem.

gem install rhodes

the installation of the gem will take time as the size of the gem is < 50 MB

7. After the gem installation ,type

$ rhodes-setup

at the terminal .The screen should come up something like this ..

Now type in the directories where you extracted the

1.Java SDK
2.Android SDK
3.Android NDK

8. Setting up the environment is complete.

Now we will generate a demo application using rhodes to test the emulator.

1.Setting up Android SDK to host an emulator of a specific android version.

2.Go to the directory where you extracted the sdk .Then go into the tools folder in the sdk and click on a file name "android".A window opens up :

3. Click on the checkbox Android 3.0 , this selects all the checkboxes in this group.Now click on install wait for a few minutes.

4. Now open your terminal and generate a new rhodes application.

rhogen app Demo
cd Demo

5. Edit the built.yml file in any text editor to change the android version to 3.0 instead of default 2.1 and add an emulator name.

6. Now go back to the terminal and type :

rake run:android

7. The android emulator will show up in a few minutes and load the rhomobile application .

Now we can go forward designing the mobile application.Happy coding :)

Export to Excel in Rails 3 without a Gem

2011-11-30T01:58:00.001+05:30

Export to Excel in Rails 3 without a Gem

Creating Demo project

rails new xcel_demo –d mysql

Creating a User model

rails g scaffold User name:string email:string content:string

Add a MIME type in \config\initializers\mime_type.rb

Mime::Type.register 'application/vnd.ms-excel', :xls

Add a xls format output to the method in the Controller

def index
    @users = User.all

    respond_to do |format|
      format.html # index.html.erb
    format.xls
      format.xml { render :xml => @users }
    end
end

Creating the view for the XLS

Now create a view to render the xls file. Here as we have modified the index method we will create a view index.xls.erb for the same in the views for Users

<h1>Listing users</h1>

<table>
<tr>
    <th>Name</th>
    <th>City</th>
    <th>Gender</th>
    <th>Phone</th>
    <th>Address</th>
    <th></th>
    <th></th>
    <th></th>
</tr>

<% @users.each do |user| %>
<tr>
    <td><%= user.name %></td>
    <td><%= user.city %></td>
    <td><%= user.gender %></td>
    <td><%= user.phone %></td>
    <td><%= user.address %></td>
</tr>
<% end %>
</table>

<br />

The text in the <th> tags are the headers and <td> tags are the data for the specified columns

Adding the link to export excel on the Index page

<%= link_to 'Export XLS', url_for(:format => 'xls') %>

This will allow the data on index page to be exported in Excel Format.

Action Mailer for Rails 3

2011-11-11T01:26:00.001+05:30

Action Mailer allows you to send email from your application using a mailer model and views.

This tutorial is about how to send an email using gmail free service in Ruby on Rails 3 and above

Creating Demo project

rails new mail_demo –d mysql

Creating a User model

rails g scaffold User name:string email:string content:string

Creating a Mailer model

rails g mailer user_mailer

Setting up the development.rb for configuring application settings to access mail smtp server

In development.rb

config.action_mailer.delivery_method = :smtp
# Defaults to:
config.action_mailer.smtp_settings = {
:enable_starttls_auto => true,
:address        => 'smtp.gmail.com',
:port           => 587,
:domain         => 'your.domain.com',
:authentication => :login,
:content_type   => "text/html",
:user_name      => 'username',
:password       => 'password'
}

config.action_mailer.perform_deliveries = true
config.action_mailer.raise_delivery_errors = true

Remember these are the basic settings needed to send mails from gmail ,other server may have different settings .

Creating the mailer

Now we will write the method in user_mailer model to send the mail .Remember in the mailer model

def send_email(user)

   recipients user.email

   from        "webmaster@example.com"

   subject     "Thank you for Registering"

   part :content_type => "text/html",

    :body => render_message("registration_confirmation", :user => user)

end

The from field can be your own or your domains email address. Please check if the from for field has invalid email the user will not be able to reply .

Creating Email Template

Now we will create a view which would form a the email template .It is named as same as the method in the model user_mailer ie. Send_email.html.erb

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html lang="en">

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      h3 { color: #f00; }

      ul { list-style: none; }

    </style>

</head>

<body>

    <div>

      <h2 id = "banner">Your account signup details are below</h2>

    </div>

    <ul><br /><br />

      <li><h2>Name: <b><%= @user.name %></b> </h2></li>

      <li>Login: <%= @user.email %></li><br /><br />

      <li>Image: <%= image_tag 'rails.png' %></li><br /><br />

      <li>Content: <%= @user.content %></li>

    </ul>



</body>

</html>

In the end add a line to the create method of the Users_controller

UserMailer.send_email(@user).deliver

The method is referred to as deliver_send_email because rails appends it to a mailer method.

Now run the server and try creating a new user . The email is sent to the address the user enters for the new record.

Action Mailer 2.3.9 — Easy email delivery and testing

2011-11-06T19:09:00.000+05:30

Action Mailer allows you to send email from your application using a mailer model and views.

This tutorial is about how to send an email using gmail free service in Ruby on Rails 2.3.9, for versions higher than this refer rails guides .

Creating Demo project

rails mail_demo –d mysql

Creating a User model

Ruby script/generate scaffold User name:string email:string content:string

Creating a Mailer model

Ruby script/generate mailer user_mailer

Setting up the development.rb for configuring application settings to access mail smtp server

In development.rb

config.action_mailer.delivery_method = :smtp

config.action_mailer.raise_delivery_errors = true

config.action_mailer.smtp_settings = {

:enable_starttls_auto => true,

:address        => 'smtp.gmail.com',

:port           => 587,

:domain         => 'your.domain.com',

:authentication => :login,

:content_type   => "text/html",

:user_name      => your full username example xyz@gmail.com',

:password       => 'password'

}

Remember these are the basic settings needed to send mails from gmail ,other server may have different settings .

Creating the mailer

Now we will write the method in user_mailer model to send the mail .Remember in the mailer model

def send_email(user)

   recipients user.email

   from        "webmaster@example.com"

   subject     "Thank you for Registering"

   part :content_type => "text/html",

    :body => render_message("registration_confirmation", :user => user)

end

The from field can be your own or your domains email address. Please check if the from for field has invalid email the user will not be able to reply .

Creating Email Template

Now we will create a view which would form a the email template .It is named as same as the method in the model user_mailer ie. Send_email.html.erb

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html lang="en">

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      h3 { color: #f00; }

      ul { list-style: none; }

    </style>

</head>

<body>

    <div>

      <h2 id = "banner">Your account signup details are below</h2>

    </div>

    <ul><br /><br />

      <li><h2>Name: <b><%= @user.name %></b> </h2></li>

      <li>Login: <%= @user.email %></li><br /><br />

      <li>Image: <%= image_tag 'rails.png' %></li><br /><br />

      <li>Content: <%= @user.content %></li>

    </ul>



</body>

</html>

In the end add a line to the create method of the Users_controller

UserMailer.deliver_send_email(@user)

The method is referred to as deliver_send_email because rails appends it to a mailer method.

Now run the server and try creating a new user . The email is sent to the address the user enters for the new record.

Squeel: Replacement for metawhere Gem in Rails 3.1

2011-09-29T11:28:00.001+05:30

Getting started

In your Gemfile:

gem "squeel"  # Last officially released gem
# gem "squeel", :git => "git://github.com/ernie/squeel.git" # Track git repo

In an initializer:

Squeel.configure do |config|
  # To load hash extensions (to allow for AND (&), OR (|), and NOT (-) against
  # hashes of conditions)
  config.load_core_extensions :hash

  # To load symbol extensions (for a subset of the old MetaWhere functionality,
  # via ARel predicate methods on Symbols: :name.matches, etc)
  # config.load_core_extensions :symbol

  # To load both hash and symbol extensions
  # config.load_core_extensions :hash, :symbol
end

The Squeel Query DSL

Squeel enhances the normal ActiveRecord query methods by enabling them to accept blocks. Inside a block, the Squeel query DSL can be used. Note the use of curly braces in these examples instead of parentheses. {} denotes a Squeel DSL query.

Stubs and keypaths are the two primary building blocks used in a Squeel DSL query, so we'll start by taking a look at them. Most of the other examples that follow will be based on this "symbol-less" block syntax.

An important gotcha, before we begin: The Squeel DSL works its magic using instance_eval. If you've been working with Ruby for a while, you'll know immediately that this means that inside a Squeel DSL block, self isn't the same thing that it is outside the block.

This carries with it an important implication: Instance variables and instance methods inside the block won't refer to your object's variables/methods.

Don't worry, Squeel's got you covered. Use one of the following methods to get access to your object's methods and variables:

Assign the variable locally before the DSL block, and access it as you would normally.
Supply an arity to the DSL block, as in Person.where{|q| q.name == @my_name} Downside: You'll need to prefix stubs, keypaths, and functions (explained below) with the DSL object.
Wrap the method or instance variable inside the block with my{}. Person.where{name == my{some_method_to_return_a_name}}

Stubs

Stubs are, for most intents and purposes, just like Symbols in a normal call to Relation#where (note the need for doubling up on the curly braces here, the first ones start the block, the second are the hash braces):

Person.where{{name => 'Ernie'}}
=> SELECT "people".* FROM "people"  WHERE "people"."name" = 'Ernie'

You normally wouldn't bother using the DSL in this case, as a simple hash would suffice. However, stubs serve as a building block for keypaths, and keypaths are very handy.

KeyPaths

A Squeel keypath is essentially a more concise and readable alternative to a deeply nested hash. For instance, in standard ActiveRecord, you might join several associations like this to perform a query:

Person.joins(:articles => {:comments => :person})
=> SELECT "people".* FROM "people"
     INNER JOIN "articles" ON "articles"."person_id" = "people"."id"
     INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
     INNER JOIN "people" "people_comments" ON "people_comments"."id" = "comments"."person_id"

With a keypath, this would look like:

Person.joins{articles.comments.person}

A keypath can exist in the context of a hash, and is normally interpreted relative to the current level of nesting. It can be forced into an "absolute" path by anchoring it with a ~, like:

~articles.comments.person

This isn't quite so useful in the typical hash context, but can be very useful when it comes to interpreting functions and the like. We'll cover those later.

Predicates

All of the ARel "predication" methods can be accessed inside the Squeel DSL, via their method name, an alias, or an an operator, to create ARel predicates, which are used in WHERE or HAVING clauses.

SQL	Predication	Operator	Alias
=	eq	==
!=	not_eq	!= (1.9 only), ^ (1.8)
LIKE	matches	=~	like
NOT LIKE	does_not_match	!~ (1.9 only)	not_like
<	lt	<
<=	lteq	<=	lte
>	gt	>
>=	gteq	>=	gte
IN	in	>>
NOT IN	not_in	<<

Let's say we want to generate this simple query:

SELECT "people".* FROM people WHERE "people"."name" = 'Joe Blow'

All of the following will generate the above SQL:

Person.where(:name => 'Joe Blow')
Person.where{{name => 'Joe Blow'}}
Person.where{{name.eq => 'Joe Blow'}}
Person.where{name.eq 'Joe Blow'}
Person.where{name == 'Joe Blow'}

Not a very exciting example since equality is handled just fine via the first example in standard ActiveRecord. But consider the following query:

SELECT "people".* FROM people
WHERE ("people"."name" LIKE 'Ernie%' AND "people"."salary" < 50000)
  OR  ("people"."name" LIKE 'Joe%' AND "people"."salary" > 100000)

To do this with standard ActiveRecord, we'd do something like:

Person.where(
  '(name LIKE ? AND salary < ?) OR (name LIKE ? AND salary > ?)',
  'Ernie%', 50000, 'Joe%', 100000
)

With Squeel:

Person.where{(name =~ 'Ernie%') & (salary < 50000) | (name =~ 'Joe%') & (salary > 100000)}

Here, we're using & and | to generate AND and OR, respectively.

There are two obvious but important differences between these two code samples, and both of them have to do with context.

To read code with SQL interpolation, the structure of the SQL query must first be considered, then we must cross-reference the values to be substituted with their placeholders. This carries with it a small but perceptible (and annoying!) context shift during which we stop thinking about the comparison being performed, and instead play "count the arguments", or, in the case of named/hash interpolations, "find the word". The Squeel syntax places both sides of each comparison in proximity to one another, allowing us to focus on what our code is doing.
In the first example, we're starting off with Ruby, switching context to SQL, and then back to Ruby, and while we spend time in SQL-land, we're stuck with SQL syntax, whether or not it's the best way to express what we're trying to do. With Squeel, we're writing Ruby from start to finish. And with Ruby syntax comes flexibility to express the query in the way we see fit.

Predicate aliases

That last bit is important. We can mix and match predicate methods with operators and take advantage of Ruby's operator precedence or parenthetical grouping to make our intentions more clear, on the first read-through. And if we don't like the way that the existing predications read, we can create our own aliases in a Squeel configure block:

Squeel.configure do |config|
  config.alias_predicate :is_less_than, :lt
end

Person.where{salary.is_less_than 50000}.to_sql
# => SELECT "people".* FROM "people"  WHERE "people"."salary" < 50000

And while we're on the topic of helping you make your code more expressive...

Compound conditions

Let's say you want to check if a Person has a name like one of several possibilities.

names = ['Ernie%', 'Joe%', 'Mary%']
Person.where('name LIKE ? OR name LIKE ? OR name LIKE ?', *names)

But you're smart, and you know that you might want to check more or less than 3 names, so you make your query flexible:

Person.where((['name LIKE ?'] * names.size).join(' OR '), *names)

Yeah... that's readable, all right. How about:

Person.where{name.like_any names}
# => SELECT "people".* FROM "people"  
     WHERE (("people"."name" LIKE 'Ernie%' OR "people"."name" LIKE 'Joe%' OR "people"."name" LIKE 'Mary%'))

I'm not sure about you, but I much prefer the latter. In short, you can add _any or _all to any predicate method, and it would do what you expect, when given an array of possibilities to compare against.

Sifters

Sifters are like little snippets of conditions that take parameters. Let's say that you have a model called Article, and you often want to query for articles that contain a string in the title or body. So you write a scope:

def self.title_or_body_contains(string)
  where{title.matches("%#{string}%") | body.matches("%#{string}%")}
end

But then you want to query for people who wrote an article that matches these conditions, but the scope only works against the model where it was defined. So instead, you write a sifter:

class Article < ActiveRecord::Base
  sifter :title_or_body_contains do |string|
    title.matches("%#{string}%") | body.matches("%#{string}%")
  end
end

Now you can write...

Article.where{sift :title_or_body_contains, 'awesome'}
=> SELECT "articles".* FROM "articles"  
   WHERE ((
     "articles"."title" LIKE '%awesome%' 
     OR "articles"."body" LIKE '%awesome%'
   ))

... or ...

Person.joins(:articles).
       where{
         {articles => sift(:title_or_body_contains, 'awesome')}
       }
# => SELECT "people".* FROM "people" 
     INNER JOIN "articles" ON "articles"."person_id" = "people"."id" 
     WHERE ((
       "articles"."title" LIKE '%awesome%' 
       OR "articles"."body" LIKE '%awesome%'
     ))

Or, you can just modify your previous scope, changing where to squeel:

def self.title_or_body_contains(string)
  squeel{title.matches("%#{string}%") | body.matches("%#{string}%")}
end

Subqueries

You can supply an ActiveRecord::Relation as a value for a predicate in order to use a subquery. So, for example:

awesome_people = Person.where{awesome == true}
Article.where{author_id.in(awesome_people.select{id})}
# => SELECT "articles".* FROM "articles"  
     WHERE "articles"."author_id" IN (SELECT "people"."id" FROM "people"  WHERE "people"."awesome" = 't')

Joins

Squeel adds a couple of enhancements to joins. First, keypaths can be used as shorthand for nested association joins. Second, you can specify join types (inner and outer), and a class in the case of a polymorphic belongs_to relationship.

Person.joins{articles.outer}
=> SELECT "people".* FROM "people"
   LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
Note.joins{notable(Person).outer}
=> SELECT "notes".* FROM "notes"
   LEFT OUTER JOIN "people"
     ON "people"."id" = "notes"."notable_id"
     AND "notes"."notable_type" = 'Person'

These can also be used inside keypaths:

Note.joins{notable(Person).articles}
=> SELECT "notes".* FROM "notes"
   INNER JOIN "people" ON "people"."id" = "notes"."notable_id"
     AND "notes"."notable_type" = 'Person'
   INNER JOIN "articles" ON "articles"."person_id" = "people"."id"

You can refer to these associations when constructing other parts of your query, and they'll be automatically mapped to the proper table or table alias This is most noticeable when using self-referential associations:

Person.joins{children.parent.children}.
       where{
         (children.name.like 'Ernie%') |
         (children.parent.name.like 'Ernie%') |
         (children.parent.children.name.like 'Ernie%')
       }
=> SELECT "people".* FROM "people" 
   INNER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id" 
   INNER JOIN "people" "parents_people" ON "parents_people"."id" = "children_people"."parent_id" 
   INNER JOIN "people" "children_people_2" ON "children_people_2"."parent_id" = "parents_people"."id" 
   WHERE ((("children_people"."name" LIKE 'Ernie%' 
         OR "parents_people"."name" LIKE 'Ernie%') 
         OR "children_people_2"."name" LIKE 'Ernie%'))

Keypaths were used here for clarity, but nested hashes would work just as well.

Functions

You can call SQL functions just like you would call a method in Ruby...

Person.select{coalesce(name, '<no name given>')}
=> SELECT coalesce("people"."name", '<no name given>') FROM "people"

...and you can easily give it an alias:

person = Person.select{
  coalesce(name, '<no name given>').as(name_with_default)
}.first
person.name_with_default # name or <no name given>, depending on data

When you use a stub, symbol, or keypath inside a function call, it'll be interpreted relative to its place inside any nested associations:

Person.joins{articles}.group{articles.title}.having{{articles => {max(id) => id}}}
=> SELECT "people".* FROM "people" 
   INNER JOIN "articles" ON "articles"."person_id" = "people"."id" 
   GROUP BY "articles"."title" 
   HAVING max("articles"."id") = "articles"."id"

If you want to use an attribute from a different branch of the hierarchy, use an absolute keypath (~) as done here:

Person.joins{articles}.group{articles.title}.having{{articles => {max(~id) => id}}}
=> SELECT "people".* FROM "people" 
   INNER JOIN "articles" ON "articles"."person_id" = "people"."id" 
   GROUP BY "articles"."title" 
   HAVING max("people"."id") = "articles"."id"

SQL Operators

You can use the standard mathematical operators (+, -, *, /) inside the Squeel DSL to specify operators in the resulting SQL, or the op method to specify another custom operator, such as the standard SQL concatenation operator, ||:

p = Person.select{name.op('||', '-diddly').as(flanderized_name)}.first
p.flanderized_name
=> "Aric Smith-diddly"

As you can see, just like functions, these operations can be given aliases.

Legacy compatibility

While the Squeel DSL is the preferred way to access advanced query functionality, you can still enable methods on symbols to access ARel predications in a similar manner to MetaWhere:

Squeel.configure do |config|
  config.load_core_extensions :symbol
end

Person.joins(:articles => :comments).
       where(:articles => {:comments => {:body.matches => 'Hello!'}})
SELECT "people".* FROM "people" 
INNER JOIN "articles" ON "articles"."person_id" = "people"."id" 
INNER JOIN "comments" ON "comments"."article_id" = "articles"."id" 
WHERE "comments"."body" LIKE 'Hello!'

This should help to smooth over the transition to the new DSL

MetaWhere Getting Started

2011-09-29T11:13:00.000+05:30

In your Gemfile:

gem "meta_where"  # Last officially released gem
# gem "meta_where", :git => "git://github.com/ernie/meta_where.git" # Track git repo

or, to install as a plugin:

rails plugin install git://github.com/ernie/meta_where.git

Example usage

Where

You can use MetaWhere in your usual method chain:

Article.where(:title.matches => 'Hello%', :created_at.gt => 3.days.ago)
=> SELECT "articles".* FROM "articles" WHERE ("articles"."title" LIKE 'Hello%')
   AND ("articles"."created_at" > '2010-04-12 18:39:32.592087')

Find condition hash

You can also use similar syntax in a conditions hash supplied to ActiveRecord::Base#find:

Article.find(:all,
  :conditions => {
    :title.matches => 'Hello%',
    :created_at.gt => 3.days.ago
  }
)

Scopes

They also work in named scopes as you would expect.

class Article
  scope :recent, lambda {|v| where(:created_at.gt => v.days.ago)}
end

Article.recent(14).to_sql
=> SELECT "articles".* FROM "articles"
   WHERE ("articles"."created_at" > '2010-04-01 18:54:37.030951')

Operators (Optionally)

Additionally, you can use certain operators as shorthand for certain Arel predication methods.

These are disabled by default, but can be enabled by calling MetaWhere.operator_overload! during your app’s initialization process.

These are experimental at this point and subject to change. Keep in mind that if you don’t want to enclose other conditions in {}, you should place operator conditions before any hash conditions.

Article.where(:created_at > 100.days.ago, :title =~ 'Hi%').to_sql
=> SELECT "articles".* FROM "articles"
   WHERE ("articles"."created_at" > '2010-01-05 20:11:44.997446')
   AND ("articles"."title" LIKE 'Hi%')

Operators are:

>> (equal)
^ (not equal)
+ (in array/range)
- (not in array/range)
!~ (not matching, only available under Ruby 1.9)
> (greater than)
>= (greater than or equal to)
< (less than)
<= (less than or equal to)
(SQL functions – more on those below)

Compounds

You can use the & and | operators to perform ands and ors within your queries.

With operators:

Article.where((:title =~ 'Hello%') | (:title =~ 'Goodbye%')).to_sql
=> SELECT "articles".* FROM "articles" WHERE (("articles"."title" LIKE 'Hello%'
   OR "articles"."title" LIKE 'Goodbye%'))

That’s kind of annoying, since operator precedence is such that you have to put parentheses around everything. So MetaWhere also supports a substitution-inspired (String#%) syntax.

With “substitutions”:

Article.where(:title.matches % 'Hello%' | :title.matches % 'Goodbye%').to_sql
=> SELECT "articles".* FROM "articles" WHERE (("articles"."title" LIKE 'Hello%'
   OR "articles"."title" LIKE 'Goodbye%'))

With hashes:

Article.where(
  {:created_at.lt => Time.now} & {:created_at.gt => 1.year.ago}
).to_sql
=> SELECT "articles".* FROM "articles" WHERE
   ((("articles"."created_at" < '2010-04-16 00:26:30.629467')
   AND ("articles"."created_at" > '2009-04-16 00:26:30.629526')))

With both hashes and substitutions:

Article.where(
  :title.matches % 'Hello%' &
  {:created_at.lt => Time.now, :created_at.gt => 1.year.ago}
).to_sql
=> SELECT "articles".* FROM  "articles" WHERE (("articles"."title" LIKE 'Hello%' AND
   ("articles"."created_at" < '2010-04-16 01:04:38.023615' AND
    "articles"."created_at" > '2009-04-16 01:04:38.023720')))

With insanity… errr, complex combinations(*):

Article.joins(:comments).where(
  {:title => 'Greetings'} |
  (
    (
      :created_at.gt % 21.days.ago &
      :created_at.lt % 7.days.ago
    ) &
    :body.matches % '%from the past%'
  ) &
  {:comments => [:body =~ '%first post!%']}
).to_sql
=> SELECT "articles".*
   FROM "articles"
     INNER JOIN "comments"
     ON "comments"."article_id" = "articles"."id"
   WHERE
   ((
     "articles"."title" = 'Greetings'
     OR
     (
       (
         (
           "articles"."created_at" > '2010-03-26 05:57:57.924258'
           AND "articles"."created_at" < '2010-04-09 05:57:57.924984'
         )
         AND "articles"."body" LIKE '%from the past%'
       )
       AND "comments"."body" LIKE '%first post!%'
     )
   ))

(*) Formatting added for clarity. I said you could do this, not that you should. :)

Join type specification

You can choose whether to use an inner join (the default) or a left outer join by tacking .outer or .inner to the symbols specified in your joins() call:

Article.joins(:comments => :moderations.outer).to_sql
=> SELECT "articles".* FROM "articles"
   INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
   LEFT OUTER JOIN "moderations" ON "moderations"."comment_id" = "comments"."id"

SQL Functions

You can use SQL functions in your queries:

Manager.joins(:employees.outer).group('managers.id').
        having(:employees => (:count.func(:id) < 3))
=> SELECT "managers".* FROM "managers"
   LEFT OUTER JOIN "employees" ON "employees"."manager_id" = "managers"."id"
   GROUP BY managers.id HAVING count("employees"."id") < 3

If you enable Symbol operators, you can just use :count[:id], instead of calling func as shown above. SQL functions work in the SELECT, WHERE, and HAVING clauses, and can be aliased with as:

Manager.select('managers.*').
        select(:find_in_set[:id, '3,2,1'].as('position'))
=> SELECT managers.*, find_in_set("managers"."id",'3,2,1') AS position
   FROM "managers"

But wait, there’s more!

Intelligent hash condition mapping

This is one of those things I hope you find so intuitive that you forget it wasn’t built in already.

PredicateBuilder (the part of ActiveRecord responsible for turning your conditions hash into a valid SQL query) will allow you to nest conditions in order to specify a table that the conditions apply to:

Article.joins(:comments).where(:comments => {:body => 'hey'}).to_sql
=> SELECT "articles".* FROM "articles" INNER JOIN "comments"
   ON "comments"."article_id" = "articles"."id"
   WHERE ("comments"."body" = 'hey')

This feels pretty magical at first, but the magic quickly breaks down. Consider an association named :other_comments that is just a condition against comments:

Article.joins(:other_comments).where(:other_comments => {:body => 'hey'}).to_sql
=> ActiveRecord::StatementInvalid: No attribute named `body` exists for table `other_comments`

Ick. This is because the query is being created against tables, and not against associations. You’d need to do…

Article.joins(:other_comments).where(:comments => {:body => 'hey'})

…instead.

With MetaWhere:

Article.joins(:other_comments).where(:other_comments => {:body => 'hey'}).to_sql
=> SELECT "articles".* FROM "articles" INNER JOIN "comments"
   ON "comments"."article_id" = "articles"."id" WHERE (("comments"."body" = 'hey'))

The general idea is that if an association with the name provided exists, MetaWhere will build the conditions against that association’s table as it’s been aliased, before falling back to assuming you’re specifying a table by name. It also handles nested associations:

Article.where(
  :comments => {
    :body => 'yo',
    :moderations => [:value < 0]
  },
  :other_comments => {:body => 'hey'}
).joins(
  {:comments => :moderations},
  :other_comments
).to_sql
=> SELECT "articles".* FROM "articles"
   INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
   INNER JOIN "moderations" ON "moderations"."comment_id" = "comments"."id"
   INNER JOIN "comments" "other_comments_articles"
     ON "other_comments_articles"."article_id" = "articles"."id"
  WHERE (("comments"."body" = 'yo' AND "moderations"."value" < 0
    AND "other_comments_articles"."body" = 'hey'))

Contrived example, I’ll admit – but I’ll bet you can think of some uses for this.

Enhanced relation merges

One of the changes MetaWhere makes to ActiveRecord is to delay “compiling” the where_values into actual Arel predicates until absolutely necessary. This allows for greater flexibility and last-second inference of associations/joins from any hashes supplied. A drawback of this method is that when merging relations, ActiveRecord just assumes that the values being merged are already firmed up against a specific table name and can just be thrown together. This isn’t the case with MetaWhere, and would cause unexpected failures when merging. However, MetaWhere improves on the default ActiveRecord merge functionality in two ways. First, when called with 1 parameter, (as is always the case when using the & alias) MetaWhere will try to determine if an association exists between the two models involved in the merge. If it does, the association name will be used to construct criteria.

Additionally, to cover times when detection is impossible, or the first detected association isn’t the one you wanted, you can call merge with a second parameter, specifying the association to be used during the merge.

This merge functionality allows you to do this…

(Comment.where(:id < 7) & Article.where(:title =~ '%blah%')).to_sql
=> SELECT "comments".* FROM "comments" INNER JOIN "articles"
   ON "articles"."id" = "comments"."article_id"
   WHERE ("comments"."id" < 7) AND ("articles"."title" LIKE '%blah%')"

…or this…

Article.where(:id < 2).merge(Comment.where(:id < 7), :lame_comments).to_sql
=> "SELECT "articles".* FROM "articles"
   INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
      AND "comments"."body" = 'first post!'
   WHERE ("articles"."id" < 2) AND ("comments"."id" < 7)"

Enhanced order clauses

If you are used to doing stuff like Article.order('title asc'), that will still work as you expect. However, if you pass symbols or arrays in to theorder method, you can take advantage of intelligent association detection (as with “Intelligent hash condition mapping,” above) and also some convenience methods for ascending and descending sorts.

Article.order(
  :title.desc,
  :comments => [:created_at.asc, :updated_at]
).joins(:comments).to_sql
=> SELECT "articles".* FROM "articles"
   INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
   ORDER BY  "articles"."title" DESC,
     "comments"."created_at" ASC, "comments"."updated_at"

Polymorphic belongs_to joins

Polymorphic associations provide great flexibility, but they can sometimes be a bit of a hassle when it comes to querying through a belongs_to association. First, you have to know what type you’re looking for to do a proper join, and then, you’re forced into using a string join in order to make it happen (which would prevent the use of MetaWhere intelligent condition mapping).

MetaWhere allows you to join polymorphic belongs_to associations like this:

Note.joins(:notable.type(Developer)).
     where(:notable.type(Developer) => {:name.matches => 'Ernie%'})
=> SELECT "notes".* FROM "notes"
   INNER JOIN "developers" ON "developers"."id" = "notes"."notable_id"
     AND "notes"."notable_type" = 'Developer'
   WHERE "developers"."name" LIKE 'Ernie%'

Using ActiveRecord objects as condition values

Wouldn’t it be nice if you could do something like this?

# Developer belongs_to Company
company = Company.find(123)
Developer.where(:company => company)

# Developer HABTM Projects
projects = [Project.first, Project.last]
Developer.joins(:projects).where(:projects => projects)

# Note belongs_to :notable, :polymorphic => true
dev1 = Developer.first
dev2 = Developer.last
project = Project.first
company = Company.first
Note.where(:notable => [dev1, dev2, project, company]).to_sql
=> SELECT "notes".* FROM "notes" WHERE (((("notes"."notable_id" IN (1, 8)
   AND "notes"."notable_type" = 'Developer') OR ("notes"."notable_id" = 1
   AND "notes"."notable_type" = 'Project')) OR ("notes"."notable_id" = 1
   AND "notes"."notable_type" = 'Company')))

With MetaWhere, you can.

Ruby on Rails Tutorials

Merging branches on two different remotes GIT

Git fatal reference error on deployment or submodule update

Submodule issues

Best Jenkins Plugins I use !

1. Compress Artifacts Plugin

2. Copy To Slave Plugin

3. Cucumber Reports Plugin

4. Delete log

5. Green Balls

6. HTML Publisher plugin

7. Jenkins disk-usage plugin

8. Jenkins Gravatar plugin

9. Timestamper

10. embeddable-build-status

Using Frank with Rubymotion

Writing acceptance tests for iOS application in Rubymotion

Happy Testing with cucumber !! Its fun.

Starting With Rubymotion

Rubymotion

So this is the first very basic application which we have put up and running on a simulator.

I will be moving step by step from the basics of using Ruby alongwith Cocoa and creating a Demo application throught it.

TCS RSS Feed Reader 123

Running on Simulator/Device

Replacing master with a branch GIT

Using Oracle JDBC with JRuby on Mac OSx

Using nested_forms gem + dropbox-paperclip + twitter-bootstrap

Cloning a specific GIT branch from a repository

Migrating code from SVN to GIT

Fix Readline error Ubuntu

Capistrano + GIT : Too many arguments while deployment

Installing RMagick with Imagemagic on Windows 7/Vista

Installing Ruby on Mac OS

STEP 1 Installing XCode

STEP 2 Install RVM

Step 3 Installing required RVM packages before installing Ruby

Step 4 Installing Ruby

Step 5 Verify the installation

Installing Ruby on Ubuntu

Step 1 Verifying

Step 2 Installing RVM on Ubuntu

Step 3 Installing required RVM packages before installing Ruby

Step 4 Installing Ruby

Step 5 Verify the installation

Installing Ruby on Windows

Step 1 :

Step 2

Step 3

Creating a native iOS application !

Step 1 Installing XCode on the system

Step 2 Download the Phonegap SDK

Step 3 Creating a XCode Project

Step 4 Changing the default compiler

Step 5 Build and Run the Project

Step 6 Include www folder in the project to start with application development

Step 7 Again BUILD & RUN

Step 8 Download JQuery Mobile bundle

Step 9 Including the JQuery mobile in the application

Step 10

Step 11 * not tested though

Setting up RHODES with an Android Emulator

Export to Excel in Rails 3 without a Gem

Export to Excel in Rails 3 without a Gem

Creating Demo project

Creating a User model

Add a MIME type in \config\initializers\mime_type.rb

Add a xls format output to the method in the Controller

Creating the view for the XLS

Adding the link to export excel on the Index page

Action Mailer for Rails 3

Creating Demo project

Creating a User model

Creating a Mailer model

Setting up the development.rb for configuring application settings to access mail smtp server

In development.rb

Creating the mailer

Creating Email Template

Action Mailer 2.3.9 — Easy email delivery and testing

Creating Demo project

Creating a User model

Step 6 Include `www` folder in the project to start with application development

Step 7 Again `BUILD & RUN`