Ruby on rails

Threads in rails:Ruby/rails support single level threading not Multithreading.Multithreading occurs when multiples thread are executed in parallel,

only one request is handled at a time. As such a standard rails app is single threaded. You can however spawn new threads within a request that would make your app multi threaded, most people never encounter this.

If you are having issues…

require 'thread' Thread.exclusive do     # stuff here end

Difference between “Extend” and “Include”

ANS:

“extend" adds methods from a module into a class as class methods.(ClassName.method)
"include" adds methods from a module into a class as instance methods.(ClassName.new.method)

It is quite easy to demonstrate this actually.

module SomeModule   def hi     puts "hello"   end end  class ExtendSample   extend SomeModule end  ExtendSample.hi  class IncludeSample   include SomeModule end  IncludeSample.new.hi

What is SCOPE in rails?

class Shirt < ActiveRecord::Base   scope :red, where(:color => 'red')   scope :dry_clean_only, joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) end  

Called => Shirt.red

(here complex conditions are defined into an scope and can be used as class method)

Action Pack.

The controller supplies data to the view, and the controller receives

events from the pages generated by the views. Because of these interactions,

support for views and controllers in Rails is bundled into a single component,

Action Pack.

Active Record

Active Record is the ORM layer supplied with Rails. It closely follows the stan-

dard ORM model: tables map to classes, rows to objects, and columns to object

attributes. It differs from most other ORM libraries in the way it is configured.

By relying on convention and starting with sensible defaults, Active Record

minimizes the amount of configuration that developers perform.

The most common templating scheme, called Embedded Ruby (Erb),

RJS views: - These allow you to create JavaScript fragments

on the server that are then executed on the browser. This is great for creating

dynamic Ajax interfaces

CONTROLLERS:

The controller is also home to a number of important ancillary services:

• It is responsible for routing external requests to internal actions. It han-

dles people-friendly URLs extremely well.

• It manages caching, which can give applications orders-of-magnitude

performance boosts.

• It manages helper modules, which extend the capabilities of the view

templates without bulking up their code.

• It manages sessions, giving users the impression of ongoing interaction

with our applications.

Ruby Is an Object-Oriented Language

Everything you manipulate in Ruby is an object, and the results of those

manipulations are themselves objects.

An object is a combination of

state (for example, the quantity and the product id) and methods that use that

state (perhaps a method to calculate the line item’s total cost).

Regular Expressions

A regular expression lets you specify a pattern of characters to be matched in

a string.

Programs

typically test strings against regular expressions using the =~ match operator:

if line =~ /P(erl|ython)/

puts "There seems to be another scripting language here"

end

Blocks and Iterators

Code blocks are just chunks of code between braces or between do...end. A

common convention is that people use braces for single-line blocks and do/end

for multiline blocks:

A method can invoke an associated block one or more times using the Ruby

yield statement.

animals = %w( ant bee cat dog elk ) # create an array

animals.each {|animal| puts animal } # iterate over the contents

Each integer N implements a times method, which invokes an associated block

N times:

3.times { print "Ho! " } #=> Ho! Ho! Ho!

The & prefix operator will allow a method to capture a passed block as a named

parameter.

def wrap &b

print "Santa says: "

3.times(&b)

print "\n"

end

wrap { print "Ho! " }

Within a block, or a method, control is sequential except when there is an

exception.

Exceptions

Exceptions are objects (of class Exception or its subclasses). The raise method

causes an exception to be raised. This interrupts the normal flow through the

code. Instead, Ruby searches back through the call stack for code that says it

can handle this exception.

begin

content = load_blog_data(file_name)

rescue BlogDataNotFound

STDERR.puts "File #{file_name} not found"

rescue BlogDataFormatError

STDERR.puts "Invalid blog data in #{file_name}"

rescue Exception => exc

STDERR.puts "General error loading #{file_name}: #{exc.message}"

end

Ruby Structure:

There are two basis structure: classes

and modules.

Line 1

class Order < ActiveRecord::Base

has_many :line_items

def self.find_all_unpaid

self.where('paid = 0')

end

def total

sum = 0

line_items.each {|li| sum += li.total}

end

end

Class definitions start with the keyword class followed by the class name (which

must start with an uppercase letter). This Order class is defined to be a sub-

class of the class Base within the ActiveRecord module.

Modules

Modules are similar to classes in that they hold a collection of methods, con-

stants, and other module and class definitions. Unlike classes, you cannot

create objects based on modules.

Modules serve two purposes. First, they act as a namespace, letting you define

methods whose names will not clash with those defined elsewhere.

Second, they allow you to share functionality between classes—if a class mixes in a

module, that module’s instance methods become available as if they had been

defined in the class. Multiple classes can mix in the same module, sharing the

module’s functionality without using inheritance. You can also mix multiple

modules into a single class.

YAML

YAML1 is a recursive acronym that stands for YAML Ain’t Markup Language. In

the context of Rails, YAML is used as a convenient way to define configuration

of things such as databases, test data, and translations. Here is an example:

development:

adapter: sqlite3

database: db/development.sqlite3

pool: 5

timeout: 5000

Marshaling Objects

Ruby can take an object and convert it into a stream of bytes that can be stored

outside the application. This process is called marshaling. This saved object

can later be read by another instance of the application (or by a totally separate

application), and a copy of the originally saved object can be reconstituted.

There are two potential issues when you use marshaling. First, some objects

cannot be dumped. If the objects to be dumped include bindings, procedure

or method objects, instances of class IO, or singleton objects, or if you try to

dump anonymous classes or modules, a TypeError will be raised.

Second, when you load a marshaled object, Ruby needs to know the definition

of the class of that object (and of all the objects it contains).

empty ! OR empty ?

Bang methods normally do something destructive to the receiver. Predicate methods return true or

false depending on some condition.

So, count ||= 0 gives count the value 0 if count doesn’t already have a value.

count ||= 0 # count = count || 0

obj = self.new

Using self.new instead returns a

new object of the receiver’s class, of subclass as well

Lambda

The lambda operator converts a block into an object of type Proc.

.

require File.dirname(__FILE__) + ’/../test_helper’

Ruby’s require method loads an external source file into our application.

This is used to include library code and classes that our application relies

on. In normal use, Ruby finds these files by searching in a list of direc-

tories, the LOAD_PATH.

What is send method in rails?

send(symbol [, args...]) → obj

__send__(symbol [, args...]) → obj

Invokes the method identified by symbol, passing it any arguments specified. You can use __send__ if the name send clashes with an existing method in obj.

It add methods in runtime ..

class Klass   def hello(*args)     "Hello " + args.join(' ')   end end  k = Klass.new k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"

Rails Caching:

1. Rails default cache:: Page Caching:

Page caching is a Rails mechanism which allows the request for a generated page to be fulfilled by the webserver

caches_page :index

2. Action Caching

One of the issues with Page Caching is that you cannot use it for pages that require to restrict access somehow. This is where Action Caching comes in. Action Caching works like Page Caching except for the fact that the incoming web request does go from the webserver to the Rails stack and Action Pack so that before filters can be run on it before the cache is served. This allows authentication and other restriction to be run while still serving the result of the output from a cached copy.

Clearing the cache works in the exact same way as with Page Caching.

caches_action :index

NOTE::

1. Page caching ignores all parameters. For example /products?page=1 will be written out to the filesystem as products.html with no reference to the page parameter. Thus, if someone requests /products?page=2 later, they will get the cached first page. Be careful when page caching GET parameters in the URL!

2. Page caching runs in an after filter. Thus, invalid requests won’t generate spurious cache entries as long as you halt them. Typically, a redirection in some before filter that checks request preconditions does the job.

1.3 Fragment Caching

Life would be perfect if we could get away with caching the entire contents of a page or action and serving it out to the world. Unfortunately, dynamic web applications usually build pages with a variety of components not all of which have the same caching characteristics. In order to address such a dynamically created page where different parts of the page need to be cached and expired differently, Rails provides a mechanism called Fragment Caching.

<% cache(:action => 'recent', :action_suffix => 'all_products') do %>

All available products:

To expire fragement:

expire_fragment(:controller => 'products', :action => 'recent', :action_suffix => 'all_products')

1.4 Sweepers

Cache sweeping is a mechanism which allows you to get around having a ton of expire_{page,action,fragment} calls in your code. It does this by moving all the work required to expire cached content into an ActionController::Caching::Sweeper subclass. This class is an observer and looks for changes to an object via callbacks, and when a change occurs it expires the caches associated with that object in an around or after filter.

class ProductSweeper < ActionController::Caching::Sweeper

observe Product # This sweeper is going to keep an eye on the Product model

# If our sweeper detects that a Product was created call this

def after_create(product)

expire_cache_for(product)

end

# If our sweeper detects that a Product was updated call this

def after_update(product)

expire_cache_for(product)

end

# If our sweeper detects that a Product was deleted call this

def after_destroy(product)

expire_cache_for(product)

end

private

def expire_cache_for(product)

# Expire the index page now that we added a new product

expire_page(:controller => 'products', :action => 'index')

# Expire a fragment

expire_fragment('all_available_products')

end

end

host: 10.179.101.110

username: ngforms

password: 12expe89

socket: /var/lib/mysql/mysql.sock

1.5 SQL Caching

Query caching is a Rails feature that caches the result set returned by each query so that if Rails encounters the same query again for that request, it will use the cached result set as opposed to running the query against the database again.

2 Cache Stores

Rails provides different stores for the cached data created by action and fragment caches. Page caches are always stored on disk.

You can set up your application’s default cache store by calling config.cache_store= in the Application definition inside your config/application.rb file or in an Application.configure block in an environment specific configuration file (i.e. config/environments/*.rb). The first argument will be the cache store to use and the rest of the argument will be passed as arguments to the cache store constructor.

config.cache_store = :memory_store

Alternatively, you can call ActionController::Base.cache_store outside of a configuration block.

You can access the cache by calling Rails.cache.

RACK

Migrations

rails generate migration AddPartNumberToProducts

rake db:migrate VERSION=20080906120000

rake db:rollback

rake db:rollback STEP=3

(will run the down method from the last 3 migrations.)

$ rake db:migrate:redo STEP=3

rake db:migrate:up VERSION=20080906120000

Active Record provides methods that perform common data definition tasks in a database independent way (you’ll read about them in detail later):

• create_table

• change_table

• drop_table

• add_column

• change_column

• rename_column

• remove_column

• add_index

• remove_index

Active Record supports the following types:

• :primary_key

• :string

• :text

• :integer

• :float

• :decimal

• :datetime

• :timestamp

• :time

• :date

• :binary

• :boolean

will append ENGINE=BLACKHOLE to the SQL statement used to create the table (when using MySQL the default is ENGINE=InnoDB).

Observers

Observers are similar to callbacks, but with important differences. Whereas callbacks can pollute a model with code that isn’t directly related to its purpose, observers allow you to add the same functionality outside of a model. For example, it could be argued that a User model should not include code to send registration confirmation emails. Whenever you use callbacks with code that isn’t directly related to your model, you may want to consider creating an observer instead.

rails generate observer User

class UserObserver < ActiveRecord::Observer

def after_create(model)

# code to send confirmation email...

end

end

As with callback classes, the observer’s methods receive the observed model as a parameter.

Observers are conventionally placed inside of your app/models directory and registered in your application’s config/application.rb file. For example, the UserObserver above would be saved as app/models/user_observer.rb and registered in config/application.rb this way:

# Activate observers that should always be running

config.active_record.observers = :user_observer

Transaction Callbacks

There are two additional callbacks that are triggered by the completion of a database transaction: after_commit and after_rollbac

Rails 3.1

What is Fingerprinting and Why Should I Care?

Fingerprinting is a technique whereby the filenames of content that is static or infrequently updated are altered to be unique to the content contained in the file.

When a filename is unique and based on its content, HTTP headers can be set to encourage caches everywhere (at ISPs, in browsers) to keep their own copy of the content. When the content is updated, the fingerprint will change and the remote clients will request the new file. This is generally known as cache busting.