Rails Tricks

1. What is request.xhr?

Ans: A request.xhr tells the controller that the new Ajax request has come, It always return Boolean    values (TRUE or FALSE)

2. What is MVC? and how it Works? 

Ans: MVC tends for Model-View-Controller, used by many languages like PHP, Perl, Python etc. The flow goes like this: Request first comes to the controller, controller finds and appropriate view and interacts with model, model interacts with your database and send the response to controller then controller based on the response give the output parameter to view, for Example your url is something like this: 
http://localhost:3000/users/new 
here users is your controller and new is your method, there must be a file in your views/users folder named new.html.erb, so once the submit button is pressed, User model or whatever defined in the rhtml form_for syntax, will be called and values will be stored into the database.

3. What things we can define in the model? 

Ans: There are lot of things you can define in models few are:
A. Validations (like validates_presence_of, numeracility_of, format_of etc.)
B. Relationships(like has_one, has_many, HABTM etc.)
C. Callbacks(like before_save, after_save, before_create etc.)
D. Suppose you installed a plugin say validation_group, So you can also define validation_group settings in your model
E. ROR Queries in Sql

6. Active record Associations Relationship

9. What is ORM in Rails?
Ans: ORM tends for Object-Relationship-Model, it means that your Classes are mapped to table in the database, and Objects are directly mapped to the rows in the table.

10. How many Types of Associations Relationships does a Model has?

Ans: When you have more than one model in your rails application, you would need to create connection between those models. You can do this via associations. Active Record supports three types of associations:

• one-to-one : A one-to-one relationship exists when one item has exactly one of another item. For example, a person has exactly one birthday or a dog has exactly one owner.
• one-to-many : A one-to-many relationship exists when a single object can be a member of many other objects. For instance, one subject can have many books.
• many-to-many : A many-to-many relationship exists when the first object is related to one or more of a second object, and the second object is related to one or many of the first object.

You indicate these associations by adding declarations to your models: has_one, has_many, belongs_to, and has_and_belongs_to_many.

11. Difference between render and redirect?
Ans:

render example:

 render :partial 

 render :new

  It will render the template new.rhtml without

  calling or redirecting to the new action.

redirect example: 

 redirect_to :controller => ‘users’, :action => ‘new’

  It forces the clients browser to request the

  new action. 

12. What is the Difference between Static and Dynamic Scaffolding?
Ans: The Syntax of Static Scaffold is like this:
ruby script/generate scaffold User Comment
Where Comment is the model and User is your controller, So all n all static scaffold takes 2 parameter i.e your controller name and model name, whereas in dynamic scaffolding you have to define controller and model one by one.

13. How you run your Rails Application without creating database ?
Ans: You can run application by uncomment the line in environment.rb

Path => rootpath conf/ environment.rb

# Skip frameworks you're not going to use (only works if using vendor/rails)

    config.frameworks -= [ :action_web_service, :action_mailer,:active_record ]

14. How to use sql db or mysql db. without defining it in the database.yml
Ans: You can use ActiveRecord anywhere!

require 'rubygems'

require 'active_record'

ActiveRecord::Base.establish_connection({

:adapter => 'postgresql',

:user => 'foo',

:password => 'bar',

:database => 'whatever'

})

class Task <>

set_table_tame "a_legacy_thingie"

def utility_methods

update_attribute(:title, "yep")

end

end

Task.find(:first)

Etcetera. It’s ActiveRecord, you know what to do. Going wild:

ActiveRecord::Base.establish_connection(:adapter => "sqlite3",

:dbfile => ":memory:")

ActiveRecord::Schema.define(:version => 1) do

create_table :posts do |t|

t.string :title

t.text :excerpt, :body

end

end

class Post <>

validates_presence_of :title

end

Post.create(:title => "A new post!")

Post.create(:title => "Another post",

:excerpt => "The excerpt is an excerpt.")

puts Post.count

15. What are helpers and how to use helpers in ROR?
Ans: Helpers (“view helpers”) are modules that provide methods which are automatically usable in your view. They provide shortcuts to commonly used display code and a way for you to keep the programming out of your views. The purpose of a helper is to simplify the view. It’s best if the view file (RHTML/RXML) is short and sweet, so you can see the structure of the output.

16. What is Active Record?
Ans: Active Record are like Object Relational Mapping(ORM), where classes are mapped to table , objects are mapped to columnsand object attributes are mapped to data in the table

17. Ruby Support Single Inheritance/Multiple Inheritance or Both?
Ans: Ruby Supports only Single Inheritance.

You can achieve Multiple Inheritance through MIXIN concept means you achieve using module by including it with classes.

18. How many types of callbacks available in ROR?
Ans:

• (-) save
• (-) valid
• (1) before_validation
• (2) before_validation_on_create
• (-) validate
• (-) validate_on_create
• (3) after_validation
• (4) after_validation_on_create
• (5) before_save
• (6) before_create
• (-) create
• (7) after_create
• (8) after_save

19. WHAT CAN RAILS MIGRATION DO?

ANS:

• create_table(name, options)
• drop_table(name)
• rename_table(old_name, new_name)
• add_column(table_name, column_name, type, options)
• rename_column(table_name, column_name, new_column_name)
• change_column(table_name, column_name, type, options)
• remove_column(table_name, column_name)
• add_index(table_name, column_name, index_type)
• remove_index(table_name, column_name)

Migrations support all the basic data types: string, text, integer, float, datetime, timestamp, time, date, binary and boolean:

• string - is for small data types such as a title.
• text - is for longer pieces of textual data, such as the description.
• integer - is for whole numbers.
• float - is for decimals.
• datetime and timestamp - store the date and time into a column.
• date and time - store either the date only or time only.
• binary - is for storing data such as images, audio, or movies.
• boolean - is for storing true or false values.

Valid column options are:

• limit ( :limit => “50” )
• default (:default => “blah” )
• null (:null => false implies NOT NULL)

20. What is the naming conventions for methods that return a boolean result?

Ans: Methods that return a boolean result are typically named with a ending question mark. For example: def active? return true #just always returning true end

21. How do the following methods differ: @my_string.strip and @my_string.strip! ?

Ans: The strip! method modifies the variable directly. Calling strip (without the !) returns a copy of the variable with the modifications, the original variable is not altered.

22. What's the difference in scope for these two variables: @name and @@name?

Ans: @name is an instance variable and @@name is a class variable

23. What is the log that has to seen to check for an error in ruby rails?

Ans: Rails will report errors from Apache in log/apache.log and errors from the Ruby code in log/development.log. If you're having a problem, do have a look at what these logs are saying. On Unix and Mac OS X you may run tail -f log/development.log in a separate terminal to monitor your application's execution.

24. What is the use of global variable $ in Ruby?

Ans: A class variable starts with an @@ sign which is immediately followed by upper or lower case letter. You can also put some name characters after the letters which stand to be a pure optional. A class variable can be shared among all the objects of a class. A single copy of a class variable exists for each and every given class.
To write a global variable you start the variable with a $ sign which should be followed by a name character. Ruby defines a number of global variables which also include other punctuation characters such as $_ and $-k.

For example: If you declare one variable as global we can access any where, where as class variable visibility only in the class Example
class Test
def h
 $a = 5
 @b = 4
Â
while $a > 0
puts $a
$a= $a - 1
end
end
end
test = Test.new
test.h
puts $a                    # 5
puts @b                   #nil

25. Where does the start_tabnav gets informations for tabs rendering in ruby rail?

Ans: The main Symbol let the start_tabnav method know to look for a special MainTabnav class where all the magic happens

26. What is the Install rail package?

Ans: There are several packages that you can download and install. The prebuilt Rails installer called Install rail which currently is only for Windows

27. What is the log that has to seen to check for an error in ruby rails?

Ans: Rails will report errors from Apache in log/apache.log and errors from the Ruby code in log/development.log. If you're having a problem, do have a look at what these logs are saying. On Unix and Mac OS X you may run tail -f log/development.log in a separate terminal to monitor your application's execution.

28. What is the use of super in ruby rails?
Ans: Ruby uses the super keyword to call the superclass (Parent class) implementation of the current method

29. What is the difference between nil and false in ruby?
Ans: False is a boolean datatype, Nil is not a data type it have object_id 4

30. How is class methods defined in Ruby?
Ans: A:def self.methodname
--------
--------
end
or
def classname.methodname
--------
--------
end

31. How is object methods defined in Ruby?
Ans:

class jak

def method1

--------
--------
end

end

obj=jak.new

It is single object
def obj.object_method_one
--------
--------
end

obj.Send(object_method_every)

It will be created every for every object creation

32. What are the priority of operators available in Ruby ?
Ans: Something that used in an expression to manipulate objects such as + (plus), - (minus), * (multiply), and / (divide). You can also use operators to do comparisons,such as with <, >, and &&. The priority is based on "BODMAS" 

33. What are the looping structures available in Ruby?

Ans: for..in
untill..end
while..end
do..end

Note: You can also use each to iterate a array as loop not exactly like loop

34. What are the object-oriented programming features supported by Ruby and how multiple inheritance supported in ?

Ans: Classes,Objects,Inheritance,Singleton methods,polymorphism(accomplished by over riding and overloading) are some oo concepts supported by ruby. Multiple inheritance supported using Mixin concept. 

35. What is the scope of a local variable in Ruby and define it scope ?

Ans: A new scope for a local variable is introduced in the toplevel, a class (module) definition, a method defintion. In a procedure block a new scope is introduced but you can access to a local variable outside the block.
The scope in a block is special because a local variable should be localized in Thread and Proc objects.

36. How is an enumerator iterator handled in Ruby?

Ans: Iterator is handled using keyword 'each' in ruby.
For example
number=[1,2,3]
then we can use iterator as
number.each do |i|
puts i end
Above prints the values of an array $no which is accomplished using iterator.

37. How is visibility of methods changed in Ruby (Encapsulation)?

Ans: By applying the access modifier : Public , Private and Protected access Modifier

38. What is the use of load,require, auto_load,require_relative in Ruby?

Ans: A method that loads and processes the Ruby code from a separate file, including whatever classes, modules, methods, and constants are in that file into the current scope. load is similar, but rather than performing the inclusion operation once, it reprocesses the code every time load is called.

auto_load - Whenever the interpreter call the method that time only it will initiate the method in hat file.

require_relative - It it to load local folder files. 

Tell us the changes between the Rails version 2 and 3?
Sol. *  (1) Introduction of bundler (New way to manage your gem dependencies)
* (2) Gemfile and Gemfile.lock (Where all your gem dependencies lies, instead of environment.rb)
* (3) A new .rb file in config/ folder, named as application.rb (Which has everything that previously environment.rb had)
* (4) Change in SQL Structure: Model.whereUser.reflect_on_association(:advertiser)(:activated => true)
* (5) All the mailer script will now be in app/mailers folder, earlier we kept inside app/models.
* (6) Rails3-UJS support. for links and forms to work as AJAX, instead of writing complex lines of code, we write:remote => true
* (7) HTML 5 support.
* (8) Changes in the model based validation syntax: validates :name, :presence => true
* (9) Ability to install windows/ruby/jruby/development/production specific gems to Gemfile.
group :production do
gem 'will_paginate'
end




21. Difference between class and module

22. How to get all associated models of rails model
         I have Site Model and i wanted to find all associated models of Site model which are having   belongs_to relationship. After doing lot headache, here is the solution i found

has_many models of Site Model

 Site.reflect_on_all_associations.map{|mac| mac.class_name if mac.macro==:has_many}.compact
=> ["Layout", "User", "SubmenuLink", "Snippet", "Asset"]

belongs_to model of Site Model

Site.reflect_on_all_associations.map{|mac| mac.class_name if mac.macro==:belongs_to}.compact
=> ["User", "Page", "User"]

To get all associations

Site.reflect_on_all_associations.map{|mac| mac.class_name}.compact
=> ["Layout", "User", "Page", "User", "SubmenuLink", "User", "Snippet", "Asset"]

23. How to get association of a model with another model

User.reflect_on_association(:advertiser)

    or 

User.reflect_on_association(:advertiser).macro

24. Difference between include and join.

    The difference between joins and include is that using the include 
    statement generates a much larger SQL query loading into memory all the 
    attributes from the other table(s).

        For example, if you have a table full of comments and you use a :joins => users to pull in all the        user information for sorting purposes, etc it will work fine and take less time than :include, but say you    want to display the comment along with the users name, email, etc. To get the information using :joins, it will have to make separate SQL queries for each user it fetches, whereas if you used :include this information is ready for use.

In addition to a performance considerations, there's a functional difference too. When you join comments, you are asking for posts that have comments- an inner join by default. When you include comments, you are asking for all posts- an outer join.

25. What is the difference between on and live in jquery?

Use of the .live() method is no longer recommended since later versions of jQuery offer better methods that do not have its drawbacks. In particular, the following issues arise with the use of .live():

• jQuery attempts to retrieve the elements specified by the selector before calling the .live()method, which may be time-consuming on large documents.
• Chaining methods is not supported. For example, $("a").find(".offsite, .external").live( ... ); is not valid and does not work as expected.
• Since all .live() events are attached at the document element, events take the longest and slowest possible path before they are handled.
• Calling event.stopPropagation() in the event handler is ineffective in stopping event handlers attached lower in the document; the event has already propagated to document.
• The .live() method interacts with other event methods in ways that can be surprising, e.g.,$(document).unbind("click") removes all click handlers attached by any call to .live()!

Follow the link http://blog.jquery.com/2011/11/03/jquery-1-7-released/
and this
http://www.jquery4u.com/jquery-functions/on-vs-live-review/#.UEbZwIogdRM


4) difference between proc and lamda in ruby

One difference is in the way they handle arguments. Creating a proc using proc {} and Proc.new {} are equivalent. However, using lambda {} gives you a proc that checks the number of arguments passed to it. From ri Kernel#lambda:

Equivalent to Proc.new, except the resulting Proc objects check the number of parameters passed when called.

An example:

p = Proc.new {|a, b| puts a**2+b**2 } # => #<Proc:0x3c7d28@(irb):1>
p.call 1, 2 # => 5
p.call 1 # => NoMethodError: undefined method `**' for nil:NilClass
p.call 1, 2, 3 # => 5
l = lambda {|a, b| puts a**2+b**2 } # => #<Proc:0x15016c@(irb):5 (lambda)>
l.call 1, 2 # => 5
l.call 1 # => ArgumentError: wrong number of arguments (1 for 2)
l.call 1, 2, 3 # => ArgumentError: wrong number of arguments (3 for 2)

In addition, as Ken points out, using return inside a lambda returns the value of that lambda, but using return in a proc returns from the enclosing block.

lambda { return :foo }.call # => :foo
return # => LocalJumpError: unexpected return
Proc.new { return :foo }.call # => LocalJumpError: unexpected return

So for most quick uses they're the same, but if you want automatic strict argument checking (which can also sometimes help with debugging), or if you need to use the return statement to return the value of the proc, use lambda.

In addition, there's also a difference in what the return statement returns from inproc versus lambda.