Ruby on Rails Agile Web Development

3 Effective Reasons for the Popularity of Ruby on Rails Development

2010-12-04T01:29:00.000-08:00

Ruby on Rails (RoR) is a full-fledged web application framework written in Ruby programming language. It is an open source technology. Rails help the web developers in building websites and applications providing structure for codes written during the development process. Ruby is an object-driven programming language which is easy to understand. It helps in providing powerful features and meta-programming capabilities. A key feature of Ruby on Rails (RoR) is that developers have to write codes for only those areas where the application deviates from the standard.

Some of the reasons for the popularity of Ruby on Rails Development include:

1. Leader amongst programming languages on the web: There are many programming languages available in the market for web development. Some of them are: Python, Java and PHP but Rails leads these programming languages. Rails give the developers a real productivity boost for developing web applications and Ruby offers domain specific languages. Hence, Ruby on Rails is considered to be leader amongst programming languages on the web.

2. Designed to make programming work easier: Ruby on Rails helps the developers in simplifying the process of writing codes. It helps in checking the code quality. If there are any errors in the codes it is directly reported to the developers and they can make adequate changes instantly. This simplifies the process of the developer and they are able to complete their task quickly. The process of programming is much faster as compared to other frameworks because of Ruby and CoC (Convention over Configuration). Ruby code is very readable and can be self- documented. This reduces the work of the developers.

3. Opportunity for developers to create better codes: As the task gets simplified with the help of Ruby on Rails, developers have the opportunity to make the programming codes into something better. They can re-work on the program and can come up with new ideas for the development process.

Ruby on Rails helps the organization in improving the overall productivity of delivering tools by eliminating the repetitive tasks. It is useful to opt for Ruby on Rails framework when there is limited time duration and the organization wants to build a powerful web application which eliminates the initial cost of IT project. Ruby on Rails development is getting much deserved mileage from people. It is lowering the entry barriers for other programming languages. If you would like to learn more about Ruby on Rails development contact an expert Ruby on Rails (RoR) developer now at: info@softwebsolutions.com.

Interesting Facts on Ruby on Rails

2010-07-21T02:26:00.000-07:00

Ruby on Rails (RoR) is a programming language used to build interactive and engaging web applications. Rails is an open source web application framework written in Ruby language. It slashes development time and increases the simplicity of coding for dynamic web sites. RoR is a widely used programming language capable of providing rich user experience. We’ve listed down some interesting facts about RoR that you may want to know:

• David Heinemeier Hansson, a Danish programmer, developed Ruby on Rails in 2003. According to Wikipedia data, Google and O’ Reilly awarded him with the Hacker of the Year award in 2005.

• He has over 1400 contributors in the rails core team responsible for extending features in the platform

• RoR is an agile framework used in majority of the web solutions. Website development is faster using the RoR solution.

• Important websites that use Ruby on Rails are Crunchbase, BaseCamp, Hulu, SpiceWorks, Penny Arcade, Twitter, Xing, and Yellowpages.com.

• The language has thousands of plugins that can be used to create unique functionality within applications.

Ruby on Rails has grown tremendously as it follows the Agile development cycle. It provides scaffolding, which can automatically construct some of the models needed for a basic website. In addition, it includes advanced application development principles such as Convention over Configuration (CoC) and Don't Repeat Yourself (DRY).

At Softweb Solutions, we have a team of Ruby on Rails developers’ proficient in providing Ruby on Rails Development Services. A broad spectrum of SEO services can be used along with RoR to improve website visibility in major search engines.

Ruby on Rails 3 All Set for Launch

2010-06-22T22:49:00.000-07:00

Ruby on Rails united with Merb Ruby frameworks to jointly participate in the development of Ruby on Rails 3 (RoR 3.0). After 18 months of collaboration which began since 2008, the open source development framework is finally close to the release. RoR 3.0 involves better modularity and robust features compared to its earlier version.

Yehuda Katz, a member of the Ruby on Rails core team and Rails framework architect, stated that they spent almost a year and a half refactoring so there is massive internal improvement. By refactoring, he clarifies that changes are made to the code with altering the functionality. Furthermore, he explains the new framework features better dependency management and API improvements.

New Features Introduced in Rails 3.0
• Dependency Management – Earlier when Rails faced issues related to dependency management, it elbowed them aside by reducing the number of dependencies. Now, as a result of coalition with Merb, dependency management is well aligned.
• Modularity – According to Katz, in the earlier version of Rails, “Rails would own a given application process on a global settings basis.” In Rails 3, the modularity and scalability of the framework is improved as the team has tried to reduce global states inside Rails.
• Improved Router – The Rails 3 router will allow developers control where inbound request go with a higher precision level compared to Rails 2.

For more details on Ruby on Rails 3.0, here’s the link.

At Softweb Solutions we offer innovative Ruby on Rails Web Application Development Services with a group of dedicated RoR developers. In addition, we provide a spectrum of SEO techniques to improve your website's visibility in all the major search engines.

Generate CSV File in Rails

2010-05-19T04:25:00.000-07:00

If You want to generate generalize function to generate csv file then keep export _to_csv function in application.rb file

def export_to_csv(data)

records = data

cls = records[0].class

data = ""

data << cls.csv_header << "\r\n"

records.each do |inst|

data << inst.to_csv << "\r\n"

end

send_data data, :type => 'text/csv', :filename => cls.name.pluralize + '.csv'

end

Controller

def export_csv

data = Model.find(:all)

export_to_csv(data)

end

Model.rb

def self.csv_header

#Column Header

"ID,Name,Controller Action ,Action Label,Is controller"

end

def to_csv

#Field_name

id.to_s << "," << name << "," << controller_action << "," << action_label <<

"," << is_controller.to_s

End

View

<% form_tag({:action => :export_csv }) do -%>

<%= submit_tag "Export To CSV",:class =>'button-1' -%>

<% end -%>

JRuby Community Unveils JRuby 1.5

2010-05-17T01:28:00.000-07:00

The JRuby Community has unwrapped JRuby 1.5, the latest upgrade of its Java implementation of the Ruby language, on 12th May, 2010. The release comes after one of the longest development cycles in the Open Source community.

The JRuby Community stated in their blog that it took them 5 months to make the changes and implement the bug fixes in the latest release. The bug fixes mainly comprised of small alterations that address compatibility issues for individual Ruby methods. According to the community, JRuby 1.5 includes 1,300 revisions and 432 bug fixes. It comes with a new native access framework which leads to improved performance and better FFI (Foreign Function Interface) support. Users will also be happy to find better support for Windows and multiple performance improvements such as improved accuracy, memory and speed in Ruby-to-Java calling.

Additionally, the latest release sees improvements in the Ruby 1.8.7 standard library and the ruby-debug tool is added by default. Rails 3 has seen the addition of multiple bug fixes, which includes reduced memory usage for Java class metadata, faster loading of Java classes, improved start-up times, and jar-in-jar support in the classloader.

According to research firm Gartner, ‘JRuby has the fastest Ruby interpreter on the market’. The reasons are that it runs the complete Ruby test suite, it runs on JVMs (Java Virtual Machines), and provides access to Java libraries. The analyst also mentions that JRuby is beneficial for enterprises that are planning to move to some dynamic languages.

For developers and project managers within non IT companies, the technology upgrade will translate into higher productivity, faster application development, and that too comes along with saving on existing Java investments. This makes the latest JRuby release an important event for the enterprises and their improved performance.

If you are looking for more information on JRuby or Ruby on Rails, contact us at info@softwebsolutions.com.

a3 Reasons to Select Ruby on Rails 2.0 to Achieve your Business Goals

2010-04-05T03:28:00.000-07:00

Ruby on Rails 2.0 (ROR 2.0), a programming language combined with a web application framework, was unveiled recently. It is an open source web project that supports Agile development methods and takes programming to the next level. In this blog we will talk about three reasons why Ruby on Rails 2.0 translates into business benefits.

Time to market is faster

Time to market is a key factor when it comes to gaining competitive edge. Compared to .NET or J2EE, the development of rich internet applications in ROR 2.0 takes lesser time. The quicker time to market combined with improved web applications and enhanced user experience makes ROR 2.0 a perfect fit.

Lowers costs

Development costs not only include application development time but also expense comprising software, support, testing, installation, customization, and many more. ROR 2.0 has a robust framework that addresses these concerns. It significantly lowers the time and efforts required to create, maintain or update web applications thereby saving operational costs. Being an open source framework, organizations save on licensing costs as well as upgradation fees.

Improved Quality

ROR 2.0 offers superior software quality as it is grounded on test driven development and automation. Developers can easily prevent errors because of continuous testing and iterations. In addition, extensive unit testing support makes it possible for developers to test changes instantaneously. These characteristics lower complexity of developing web applications and allow developers to focus on application logic improving the quality of software applications.

Thus, ROR 2.0 gives organizations ample reasons to select it for achieving their business goals. It allows radical productivity improvements and enables developers to provide enhanced performance. Please share your own opinions on ROR 2.0 in the comments section below.

Delegation with Rails

2009-12-03T04:20:00.001-08:00

Why delegation?

Before going to detail let me start with an example , we have a two models named User and profile having has-one association.

class User < ActiveRecord::Base
has_one :profile
end

class Profile < ActiveRecord::Base
belongs_to :user
end

Suppose Profile have attributes like first_name, last_name, phone etc and @user is the instance of User class.now to find name or phone of an user we have two ways -

1. Using dot-magic

FirstName = @user.profile.first_name

This is simple but becomes bulky for long chain associated object.For example @user.sth.sth.sth.sth…some_attribute

2. Using delegation

Instead we can delegate desired attributes in User model. Here is the code to add

class User < ActiveRecord::Base
has_one :profile
[:first_name, :last_name, :phone, ...etc.].each {|attr| delegate attr, :to => :profile}
end

Lets see usage of delegation in depth

Delegatation in Rails

In ruby on rails Delegation provide us a fine way over dot-magic. Using delegation it is easy to access associated object’s attributes. Delegation is a feature Rails introduced in it’s 2.2 version.The concept of delegation is to take some methods and send them off to another object to be processed.Delegate simply delegates a method to another class.This is useful if you have a lot of cases where you are referring to fields in associated classes.

Let me explain this with a brief example:

Suppose you have a User class for anyone registered on your site, and a Consumer class for those who have actually placed orders:

class User < ActiveRecord::Base
   belongs_to :consumer
end

class Consumer < ActiveRecord::Base
has_one :user
end

As for now, if you are in a Consumer instance, you can get their User information doing @consumer.user.name, or @consumer.user.email. Delegation allows you to simplify this:

class User < ActiveRecord::Base
   belongs_to :consumer
end

class Consumer < ActiveRecord::Base
has_one :user
delegate :name,:email,:to => :user
end

Now you can refer to @consumer.name and @consumer.email to retrieve and set values for those attributes directly.

This is all well and good if you can be sure that there will always be a user for any given consumer. If consumer’s user is nil and name is called, however, an exception will be raised (because nil.name is undefined). There’s a new feature in Rails 2.2 that relate to delegation and using a prefix for delegated methods also you can set default value by extending delegate method

Delegate with default

class Consumer < ActiveRecord::Base
has_one :user
delegate :name,:to => :user, :default => "Sapna Prajapati"
end

Delegate with prefixes

Delegate prefixes just appeared in edge Rails and will work in Rails 2.2. If you delegate behavior from one class to another, you can now specify a prefix that will be used to identify the delegated methods. For example:

class User < ActiveRecord::Base
   belongs_to :consumer
end

class Consumer < ActiveRecord::Base
   has_one :user
   delegate :name,:email,:to => :user ,prefix => true
end

This will produce delegated methods @consumer.user_name and @consumer.user_email.

The problem is if you refactor user or consumer , you’ll have to go back and fix all the places you did this access chaining as well. Means if you rename the user class, you’re almost always going to want to rename that prefix too.But delegates provide custom prefixes so you will end up to change.

Delegate with custom prefixes

class User < ActiveRecord::Base
   belongs_to :consumer
end

class Consumer < ActiveRecord::Base
   has_one :user
   delegate :name,:email,:to => :user ,prefix => :owner
end

This will produce delegated methods @consumer.owner_name and consumer.owner_email.

Rails Testing Process

2009-10-14T19:47:00.000-07:00

Rails Testing

Types of testing in Rails

• Unit testing - Tests models
• Functional testing - Tests controllers
• Integration testing - Tests multiple controllers

Fixtures

• Textual representations of table data
• Is used to populate the database before testing

Unit testing Class

• Subclass of ActiveSupport::TestCase class
> class PostTest < ActiveSupport::TestCase
• It requires test_helper
> require File.dirname(__FILE__) + '/../test_helper'

• Test methods are prefixed with test_
> test_my_method

• Within test methods, assert methods are used to test the result
> assert methods asserts that the result is true

Example
Fixture
one:
id: 1
account_id: 1
name: "Test Post"

# Create test
def test_should_create_post
post = Post.new(:title=>"test title", :body=>"test body")

# make sure save is successful
assert post.save
end

# Find test
def test_should_find_post

# Get the id of the test data named as one
post_id = posts(:one).id

# make sure find is successful by checking an exception
assert_nothing_raised {Post.find(post_id)}
end

Example – 2
require File.dirname(__FILE__) + '/../test_helper'
class CompanyTest < Test::Unit::TestCase
fixtures :companies
# Replace this with your real tests.
    def setup
    @companies_name = companies(:one)
end
def test_failure_for_Retailer_duplicate
    new_retailer = Retailer.create(:name => 'Walmart')
    assert !new_retailer.valid?
end
def test_failure_for_supplier_duplicate
    new_supplier = Supplier.create(:name => 'Supplier 2')
    assert !new_supplier.valid?
end
def test_company_name_required
    # Test that the initial object is valid
    assert_valid(@companies_name)
    # Test that it becomes invalid by removing the name
    @companies_name.name = nil
    assert !@companies_name.valid?
    assert(@companies_name.errors.invalid?(:name), "Expected an error on validation")
end
end

Functional testing

Testing of controller methods

Define fixtures value
Fixture
user:
   id: 1
   first_name: Admin
   last_name: patel

class Admin::UserController
def test_show
    get :show, :id => 1
    # assert that the http response was 200
    assert_response :success
    # assert that the correct template was rendered
    assert_template 'admin/userr/show'
    # assert that the variable @user was assigned
    assert assigns( :user)
    # assert that the variable @user was assigned with the correct values
    assert_equal 'admin', assigns(:user).first_name
    assert_equal 'patel', assigns(:user).last_name
end
end

asserts that the response is one of the following types:
• :success - Status code was 200.

Ex.
def test_should_get_index_successfully
get :index
assert_response :success
end

Assert Rendering of a Particular Template

The assert_template method makes it simple to test whether a particular template was rendered by the action under test:
def test_get_index_should_render_index_template
get :index
assert_template ‘index’
end

• :redirect Status code was in the 300–399 range.
def test_accessing_protected_content_redirects_to_login
get :protected
assert_redirected_to :controller => “session”, :action => “new”
end

Assert Setting of Flash Messages
The flash convenience method gives you direct access to the flash hash of the user’s session.

def test_accessing_protected_content_redirects_to_login
post :create ... # bad attributes
assert_equal “Problem saving. Check form and try again.”,
flash[:error]
end

Assert select
def page_has_one_link_back_to_user_page
get :show, :id => 1
assert_select “a[href=?]”,
url_for(:controller=>”user”, :id=>user_id),
:count => 1, :text => “Back to page”
end

• :missing Status code was 404.
• :error Status code was in the 500–599 range.

integration
Where exactly we should use Integration Testing ?

Whenever we need to test a series of functionalities which belongs to more than one controller , we should go for Integration Testing and not the Functional one.

Since the functional and unit testing are controller and model centric respectively, rails automatically creates the related functional and unit tests files. But as integrations testing is not confined in any criteria of a specific controller or model, we have to create the integrations file manually…Well, nothing is headache in rails. Its a simple pre-written script, all you need is to call that script with a name you like for whole story you wish to test in the integration test.

require "#{File.dirname(__FILE__)}/../test_helper"
s
class StoriesTest < ActionController::IntegrationTest
fixtures :accounts, :ledgers, :registers, :people
def test_signup_new_person
    go_to_login
    go_to_signup
    signup :name => "Boby", :user_name => "boby", :password => "boby123"
end
private
def go_to_login
      get "/login"
      assert_response :success
      assert_template "login/index"
end
def go_to_signup
      get "/signup"
     assert_response :success
     assert_template "signup/index"
   end
   def signup(options)
     post "/signup", options
     assert_response :redirect
     follow_redirect!
     assert_response :success
     assert_template "ledger/index"
   end
end

Target Description
rake db:test:clone The clone task re-creates the test database from the current environment’s database schema. rake db:test: The clone_structure task re-creates the test database clone_structure using the structure of the development database. Similar to db:test:clone, except that it only copies over the schema of the database and not the contents. You shouldn’t need to invoke either of these tasks during everyday work, because they are dependencies of other testing tasks.rake db:test:prepare Prepares the test database for a test run and loads the current development schema into it. If you are running a test directly after having made schema changes to your database, you have to run this task first or your test will fail. rake db:test:purge Empties the test database.rake test The test target is marked as the default in standard Rails rakefiles, meaning you can run it simply by typing rake at the command line. It runs all tests in test/units and test/functionals folders.rake test:functionals Run only the tests in the test/functionals folder.rake test:integration Run only the tests in the test/integration folder. rake test:units Run only the tests in the test/units folder.rake test:recent Run only tests that have been modified in the last 10 minutes. rake test:uncommitted Run only the tests that are modified according to Subversion

ActiveResource with Rails

2009-10-14T04:33:00.000-07:00

ActiveResource Overview

ActiveResource is part of Rails 2.0. ActiveResource is a Rails library for the development of REST-based web service clients. ActiveResource is not a part of Rails 1.2 but is available via the development trunk and can be installed using svn, the subversion source control application:

> cd ontrack/vendor
> mv rails rails-1.2
> svn co http://dev.rubyonrails.org/svn/rails/trunk rails

It implements object-relational mapping for REST webservices to provide transparent proxying capabilities between a client (ActiveResource) and a RESTful service (which is provided by Simply RESTful routing in ActionController::Resources).

Model classes are mapped to remote REST resources by Active Resource much the same way Active Record maps model classes to database tables. When a request is made to a remote resource, a REST XML request is generated transmitted, and the result received and serialized into a usable Ruby object.
There are two benefits to understanding Active Resource. The first benefit is the ability to quickly and easily create an Active Resource client for someone else's web service. The second benefit is being able to easily expose your own application to Active Resource clients. We're going to take a look under the hood at the communication between an Active Resource client and a Rails application in order to build a complete understanding of web services in Rails.

Configuration and Usage

Putting ActiveResource to use is very similar to ActiveRecord. It’s as simple as creating a model class that inherits from ActiveResource::Base and providing a site class variable to it:
class User < ActiveResource::Base
self.site = "http://softwebsolutions.com:3000/"
end
In the case where you already have an existing model with the same name as the desired RESTful resource you can set the element_name value.
class UserResource < ActiveResource::Base
self.site = "http://softwebsolutions.com:3000/"
self.element_name = "user"
end

Protocol

Active Resource is built on a standard XML format for requesting and submitting resources over HTTP. It mirrors the RESTful routing built into ActionController but will also work with any other REST service that properly implements the protocol.
• GET requests are used for finding and retrieving resources.
• POST requests are used to create new resources.
• PUT requests are used to update existing resources.
• DELETE requests are used to delete resources.

Methods

Now the User class is REST enabled and can invoke REST services very similarly to how ActiveRecord invokes lifecycle methods.
=== Find ===
Find requests use the GET method and expect the XML form of whatever resource/resources is/are being requested.So, for a request for a single element, the XML of that item is expected in response:

# Expects a response of
#
# < user >
< id type="integer" >1< / id>
< attribute1 >value1< / attribute1 >< attribute2 >..< / attribute2 >
< / user >
#
# for GET http://softwebsolutions.com:3000/user/1.xml
#
user = User.find(1)

=== Create ===

Creating a new resource submits the XML form of the resource as the body of the request and expects a 'Location' header in the response with the RESTful URL location of the newly created resource. The id of the newly created resource is parsed out of the Location response header and automatically set as the id of the ARes object.

# < user >< first >Ruby< / first >< / user >
#
# is submitted as the body on
#
# POST http://softwebsolutions.com:3000/user.xml
#
# when save is called on a new User object. An empty response is
# is expected with a 'Location' header value:
#
# Response (201): Location: http://softwebsolutions.com:3000/user/2
#
user = User.new(:first => 'Ruby')
user.save #=> true
user.id #=> 2

=== Update ===

'save' is also used to update an existing resource - and follows the same protocol as creating a resource with the exception that no response headers are needed - just an empty response when the update on the server side was successful.

# < user >< first > Ruby < / first > < / user >
#
# is submitted as the body on
#
# PUT http://softwebsolutions.com:3000/user/1.xml
#
# When save is called on an existing User object. An empty response is expected
with code (204)
#
user = User.find(1)
user.first #=> 'Ruby'
user.first = 'Jhon'
user.save #=> true

=== Delete ===

Destruction of a resource can be invoked as a class and instance method of the resource.

# A request is made to
#
# DELETE http://softwebsolutions.com:3000/user/1.xml
#
# for both of these forms. An empty response with
# is expected with response code (200)
#
user = User.find(1)
user.destroy #=> true
user.exists? #=> false

obj_user.delete(2) #=> true
obj_user.exists?(2) #=> false

As you can see, the methods are quite similar to Active Record‘s methods for dealing with database records. But rather than dealing directly with a database record, you‘re dealing with HTTP resources.

Custom Methods

Since simple CRUD/lifecycle methods can‘t accomplish every task, Active Resource also supports defining your own custom REST methods. To invoke them, Active Resource provides the get, post, put and delete methods where you can specify a custom REST method name to invoke.
A module to support custom REST methods and sub-resources, allowing you to break out of the "default" REST methods with your own custom resource requests. For example, say you use Rails to expose a REST service and configure your routes with:
map.resources :user,:new => { :register => :post },
:member => { :promote => :put, :deactivate => :delete }
:collection => { :active => :get }

This route set creates routes for the following HTTP requests:

POST /user/new/register.xml # UserController.register
PUT /user/1/promote.xml # UserController.promote with :id => 1
DELETE /user/1/deactivate.xml # UserController.deactivate with :id => 1
GET /user/active.xml # UserController.active
Using this module, Active Resource can use these custom REST methods just like the standard methods.
class User < ActiveResource::Base
self.site = "http://localhost:3000"
end

User.new(:name => 'Ruby’).post(:register)
# POST /user/new/register.xml # => { :id => 1, :name => 'Ruby' }

User.find(1).put(:promote, :position => 'Manager')
# PUT /user/1/promote.xml

User.find(1).delete(:deactivate)
# DELETE /user/1/deactivate.xml

User.get(:active)
# GET /user/active.xml
# => [{:id => 1, :name => 'Ruby'}, {:id => 2, :name => 'Jhon'}]

Validation errors

Active Resource supports validations on resources and will return errors if any these validations fail (e.g., "First name cannot be blank" and so on). These types of errors are denoted in the response by a response code of 422 and an XML representation of the validation errors. The save operation will then fail (with a false return value) and the validation errors can be accessed on the resource in question.
user = User.find(1)
user.first # => ''
user.save # => false

# When
# PUT http://softwebsolutions.com:3000/people/1.xml
# is requested with invalid values, the response is:
#
# Response (422):
# First cannot be empty
#

user.errors.invalid?(:first) # => true
user.errors.full_messages # => [‘first cannot be empty']

Authentication

Many REST APIs will require authentication, usually in the form of basic HTTP authentication. Authentication can be specified by:
putting the credentials in the URL for the site variable.
class User < ActiveResource::Base
self.site = "http://admin:admin123@softwebsolutions.com:3000/"
End

Defining user and/or password variables
class User < ActiveResource::Base
self.site = "http:// softwebsolutions.com:3000/"
self.user = "admin"
self.password = "admin123"
end

Headers

ActiveResource allows for the setting of HTTP headers on each request too. This
can be done in two ways. The first is to set it as a variable:

Class User< ActiveResource::Base
self.site = ‘http://localhost:3000’
@headers = { ‘x-flavor’ => ‘softweb’ }
End

This will cause every connection to the site to include the HTTP header:
HTTPX- FLAVOR: softweb. In our controller we could use the header value.

ActiveResource Testing

The HttpMock class makes it easy to test your Active Resource models by creating a set of mock responses to specific requests. To test your Active Resource model, you simply call the ActiveResource::HttpMock.respond_to method with an attached block.
Example

def setup
@user = { :id => 1, :name => "Ruby" }.to_xml(:root => "user")
ActiveResource::HttpMock.respond_to do |mock|
mock.post "/user.xml", {}, @user, 201, "Location" => "/user/1.xml"
mock.get "/user/1.xml", {}, @user
mock.put "/user/1.xml", {}, nil, 204
mock.delete "/user/1.xml", {}, nil, 200
end
end

def test_get_user
user = User.find(1)
assert_equal "Ruby", user.name
end

Multiple Database Connection in Ruby on Rails

2009-10-14T01:48:00.000-07:00

As you are aware with rails (opensource technology). So, you know that ActiveRecord allowed one connection to database at a time.

Ruby on Rails sets up the connection depending on your application’s database.yml file. In database.yml file you set up configration environmentwise.

As I active record allow to access single database but you want to access more than one databases than it required to have multiple connection at a time. Now you think that how this possible. So Rails provides gem to implement you need. Follow the below steps:

1. Install gem
sudo gem install magic_multi_connections

2. After installing gem there is one patch required in connect.rb
replace

raise NameError.new ( "uninitialized constant # (const_id)") unless
target_class target_class
with

return unless target_class

3. Now edit the config/database.yml file to create some more databases:

development:

adapter: mysql
encoding: utf8
database: app_development
username: tester
password: testerpwd
host: localhost

development_clonex:

adapter: mysql
encoding: utf8
database: appx_development
username: tester
password: testerpwd
host: localhost

Default in rails main application database has read-write permission , and the other databases than you default application database have read-only pemission.

4. Now in environment.rb ,you have to add below code:

require 'magic_multi_connections'
connection_names = ActiveRecord::Base.configurations.keys.select do |name|
name =~ /^#{ENV['RAILS_ENV']}_clone/
end

@@connection_pool = connection_names.map do |connection_name|
Object.class_eval <<-EOS
module #{connection_name.camelize}
establish_connection :#{connection_name}
end
EOS

connection_name.camelize.constantize
end

5. Next, you create same clone for databases which you have access by following below steps.

cp config/environments/development.rb config/environments/development_clonex.rb

6. Now, You want to migrate the new databaseclone than only follow below step.

rake db:migrate RAILS_ENV=development_clonex

7. Lets check whether multiple pool created or not and we are able to access data from different database or not through console.
$ ruby script/console

· Check for connection pool

>> @@connection_pool
=> [DevelopmentClonex]

As we create clonex than it listed here. If you create more than one then you have array with multiple clone.

· Now access table from other database by
>> DevelopmentClonex::Model_name.model_methods

Eg. @users = DevelopmentClonex::User.find(:all)
Puts @users.count
Now use other features of multi_magic_connection.

Hope this article will help you. If you have any suggestion or query than just leave comment here.

9th Anniversary of Softweb Solutions

2009-04-02T02:31:00.000-07:00

Softweb Solutions peeping into past success and planning for future on its 9th anniversary

Chicago, Illinois April 1, 2009 - Softweb Solutions, a leading IT Consultant is celebrating its 9th anniversary with great zeal. It is in short time span that Softweb has earned a remarkable name in the IT industry.

“I am extremely happy with the success of Softweb. I want to offer my heartfelt thanks to all the employees who have satisfied the clients with their dedication and skills; and who have created a great foundation for company’s growth.” said Mr. Ripal Vyas, CEO of Softweb.

Since its inception, Softweb has been among the most dynamic names of the Software industry delivering Custom Software Development, Website Design and Development, ERP Implementation, Customer Relationship Management, Content Management System and Search Engine Marketing.

In its small journey Softweb has achieved few of the most prestigious titles; such as

• Microsoft Gold Certified Partner
• Microsoft Dynamics NAV Partner
• ISO 9001:2000

Softweb also has worked for Fortune 500 clients and delivered excellent services satisfying all their needs. Having highly skilled resources across North America, Europe, and India, Softweb can take full advantage of multiple time zones to deliver cost effective services with quality and flexibility.

Ruby on Rails 2.3 Update Release

2009-03-18T05:21:00.000-07:00

Ruby on Rails community is adding value to the popular open source by releasing the latest update of it. They have released version 2.3 of Ruby on Rails that is one of the most popular open-source web development framework. The community had initially delivered the Release Candidate version so that the developers could test it before the final update.

The new update has two major architectural changes:

1. Complete integration of Rack modular web server interface
2. Renewed support for Rails Engines

The top features in the Rails update that would make it more popular are:

• Templates: Allows new skeleton of Rails application to be built your way with your default stack of gems, configs, and more
• Engines: Share reusable application pieces complete with routes that just work, models, view paths and the works
• Rack: Rails now runs on Rack which gives you access to all the middleware goodness
• Metal: Write super fast pieces of optimized logic that routes around Action Controller
• Nested Forms: Deal with complex forms so much easier

To know more about RoR and its benefits approach RoR Consultants Chicago.

Principles like CoC and DRY making Ruby on Rails widely used....

2009-02-21T01:50:00.000-08:00

An increase of competition has made it important to serve the best applications in lesser time for IT companies. That is preferable for not only the programmers but also for the clients. And Rails give the scope to develop powerful applications in half of the time.

As I had mentioned earlier ROR is an open source framework, consisting of Ruby, object oriented programming language and Rails, web development framework. Rails is remarkable for its extensive use of JavaScript libraries Prototype and Script.aculo.us for AJAX.

Ruby on Rails emphasizes on two things:

Convention over Configuration (CoC): CoC means the developer only needs to specify unconventional aspects of application which reduces the code and also repetition.

For example, if there is a class Sale in the model, the corresponding table in the database is called sales by default. It is only if one deviates from this convention, such as calling the table "products sold” that the developer needs to write code regarding these names.

Don’t Repeat Yourself (DRY): DRY means that the information is located in a single, unambiguous place.

For example, using the ActiveRecord module of Rails, the developer does not need to specify database column names in class definitions. Instead, Ruby on Rails can retrieve this information from the database

With the release of Rails version 2.2, it can now expand its market as it has been released with features like internationalization framework, thread safety, easy access to HTTP caching, compatibility with Ruby 1.9 , JRuby and new documentation.

Softweb Solutions with a team of dedicated ROR developers and programmers offers Ruby on Rails Web Development and RoR Content Management Services using the latest RoR 2.2 version.

Improved Enterprise Applications with the latest technologies like Zend, jQuery and Flex

2009-02-12T02:22:00.000-08:00

With the collaboration of Adobe and Zend, now it has become easier to integrate the flexibility, productivity and reliability of Zend’s PHP with highly beneficial Adobe Flex and Flash that can serve the better user experience. The collaboration of Zend and Adobe can deliver the applications that combine PHP with Flex and so hand out highly engaging applications to both browser and desktop. Now it has become easier to deliver RIAs which are built using Flex and PHP that can enhance the employee productivity. jQuery can also be used with a combination of Zend Framework and PHP for superior web applications.

Zend Framework is an open source PHP framework that has become famous for its support for fast and proficient creation of PHP applications. It enables the PHP developers to create powerful applications quickly and perhaps so it is recognized as one of the best frameworks in PHP. It follows the principle of “extreme simplicity” that can make it very easy for the developers to learn and use it.

RIA (Rich Internet Application), Flex is well-known for its features like rapid web development and more engaging user experience. And so the collaboration of Zend and Adobe together provide flexibility and reliability of PHP with the powerful user experience of Adobe Flex and Flash.

For more information on how Zend, PHP and Flex, together could be harnessed for Web Application Development, visit our corporate website.

Is a hyped phenomenon in the web world- open source Ruby on Rails worth?

2009-02-05T23:08:00.000-08:00

RoR is being highly discussed phrase in the realm of web development. Thinking why is it so? Ruby on Rails can be defined as a full stack framework which means that this framework covers everything which is needed to build a web application. It is an open source web application framework that can help you building web applications with an out of the box architecture. It is written in Ruby which is an object oriented language with clean syntax that can make programming enjoyable. Moreover Rails could help you creating a web application almost ten times faster than you do with regular java framework and that too without compromising with the quality. As it uses the MVC architecture pattern, it organizes the application programming that provides flexibility and simplicity. RoR is a great framework for them who have high timeliness and budget constraint.

Softweb Solutions having a rich experience as an IT consultant has been delivering Agile Web Development with Rails to its global clients. Our team includes expert developers for RoR, Flex, Web 2.0, Agile Development, AJAX and more. Our RoR team with great know how of Rails and jQuery can serve the bespoke solutions. Be it a simple corporate web site or an ecommerce portal or CMS, we can offer overwhelming web applications for all.