Rails... Rails... Rails

Rails 3.0.9 has been released!

2011-07-12T22:44:00.000+08:00

CCH : From Riding Rails

Posted by aaronp June 16, 2011 @ 10:27 AM
Hi everybody!
Rails 3.0.9 has been released! Since I am at Nordic Ruby, I will deem this Nordic Ruby Edition. ;-)
The main boogs fixed in this release are problems dealing with modifications of SafeBuffers.
gem install rails or update your Gemfile and bundle update while it's hot!

CHANGES

The major changes in this release of Rails are bug fixes surrounding modifications to SafeBuffer strings. We had places that were modifying SafeBuffers and those places raised exceptions after the security fixes in the 3.0.8 release.
We've since updated those code paths, and now we have this nice release for you today!
Please check the CHANGELOG files in each section on github for more details.
For an exhaustive list of the commits in this release, please see github.

Gem checksums

SHA-1:

fb8f3c0b6c866dbad05ec33baf2af7e851f9d745 actionmailer-3.0.9.gem
9bc2c05463962320d0497bb2e30f4ffa66ed4f79 actionpack-3.0.9.gem
2c1004747a22f756722cf95605398bf9ba6244ed activemodel-3.0.9.gem
285759d41c79460a3f49d26d8a0b3f8c9279e868 activerecord-3.0.9.gem
28f2b296525caeca1341467b5f1bbb90de88aaa7 activesupport-3.0.9.gem
09d52fdcbeefba31dd267d3d7484332ec30f7539 rails-3.0.9.gem
8b46dbeddb56e2e4b4ebfb5312fe81eb865a47e7 railties-3.0.9.gem

Please enjoy this release of Rails!

Rails 3.0.5 has been released!

2011-03-22T17:45:00.000+08:00

CCH: From Riding Rails Blog

Posted by spastorino February 27, 2011 @ 03:52 PM

Aaron Patterson showed us some tenderlove this week by releasing Rails 3.0.5. Have a peek at what got updated.

Bugs Fixed

Fix when gzip returns a UTF-8 string on Ruby 1.9, when it is actually binary. commit

Active Record limit values will not escape Arel SQL Literal nodes. commit

Relation#where calls will always produce AND statements regardless of how conditions hashes behaves (reverting 00693209ecc).

Observer callbacks will only be executed once when using STI classes in ActiveRecord. commit

Deprecations Added:

Deprecate Relation#& alias for Relation#merge. commit

Deprecated support for interpolated association conditions with the :conditions => ‘foo = #{bar}’ syntax, and added the new interpolation syntax which is :conditions => proc { “foo = #{bar}” }. commit

This is not a complete list of changes. The complete list of changes can be found here

SHA1 Checksums:

actionmailer-3.0.5.gem b25750c8126aa21db27d7b0ee829b2e94e525ebc

actionpack-3.0.5.gem 0a6f7f9ac2960ff224c913877a2917e1bea80df3

activemodel-3.0.5.gem 1556900a7afa1cdcdf4641edbcdd2c24f98bb2de

activerecord-3.0.5.gem 33dd05d7362931564f6f15ea7130cc27a5fc09e8

activeresource-3.0.5.gem 758f893cbb7ef945c857bf4ca044b94017bdc437

activesupport-3.0.5.gem 195fa3f7fa044134703a655cdb906edb515286c4

rails-3.0.5.gem 32322bf9952d76c5fa0054c8533c0c58609f40aa

railties-3.0.5.gem 3dddf14736dec991c3dbbe2d89495613e72c19c7

Rails for Zombies

2011-02-05T19:28:00.002+08:00

Posted by Gregg Pollack November 18, 2010 @ 07:01 PM on Riding Rails

This morning my team over at Envy Labs released a free online tutorial called Rails for Zombies. The website combines screencasts with in-browser coding to provide an interactive learning experience teaching the basics of Ruby on Rails.

Learning Rails for the first time should be fun, and Rails for Zombies allows you to get your feet wet without any setup or configuration. At the moment the application has five episodes. Each episode consists of a single screencast followed by a group of exercises which must be completed before moving forward. Once you complete all the labs, you unlock a hidden video which shows you where to go to continue your Rails learning.
If you have any friends who need to get started with Rails, hopefully this will help.

.Rails 3.0.3: Faster Active Record plus fixes Released on 15 Nov 2010

2011-02-05T19:27:00.000+08:00

Posted by David November 15, 2010 @ 07:34 PM on Riding Rails
How about some free speed? Well, here you go. Rails 3.0.3 includes a much faster version of Active Record that reclaims the performance lost when we went from Rails 2.3.x to 3.x and then some. Aaron Patterson has done a phenomenal job benchmarking, tweaking, and tuning the ARel engine that underpins Active Record 3 and the result is Teh Snappy.
You can read more about Aaron’s work in his ARel 2.0 write-up. If you dare, you can also have a look at his RubyConf slides that went over the rewrite and speed-up in even greater detail (warning: there are slides of boys kissing!).
In addition to the free speed, we’ve also included a truckload of minor fixes. So everything just works better and faster. What more can you ask for? Oh, that it’s a drop-in replacement for Rails 3.0—there are no API changes. You got it.
See all the changes on Github. Install the latest version using gem install rails. Or bind yourself to the v3.0.3 tag.
Enjoy!
Note: Active Record 3.0.3 is mistakenly reporting its tiny version as 1 instead of 3. This has no impact on anything you do unless you were specifically checking that tiny version. But if it bothers you lots, it’s fixed on the 3-0-stable branch.

Security Vulnerability in Nested Attributes code in Ruby On Rails 2.3.9 and 3.0.0

2011-02-05T19:25:00.000+08:00

Posted by michael October 15, 2010 @ 02:35 AM on Riding Rails

There is a vulnerability in the nested attributes handling code in some versions of Ruby on Rails. An attacker could manipulate form parameters and make changes to records other than those the developer intended. This vulnerability has been assigned the identifier CVE-2010-3933.

Versions Affected: 3.0.0, 2.3.9
Not affected: Versions earlier than 2.3.9 and applications which do not use accepts_nested_attributes_for
Fixed Versions: 3.0.1, 2.3.10

Impact

An attacker could change parameter names for form inputs and make changes to arbitrary records in the system. All users running an affected release should upgrade immediately.

Releases

The 3.0.1 and 2.3.10 releases are available at the normal locations. The 3.0.1 release consists solely of 3.0.0 with the security issue fixed, 3.0.2 will follow shortly and include other bugfixes as well as this fix. 2.3.10 is a regular release in the 2.3 series.

Workarounds

There are no feasible workarounds for this issue.

Patches

To aid users who aren’t able to upgrade immediately we have provided patches for the two supported release series. They are in git-am format and consist of a single changeset.

Please note that only the 2.3.x and 3.0.x series are supported at present. Users of earlier unsupported releases are advised to upgrade as soon as possible.

Credits

Thanks to Matti Paksula and Juha Suuraho of Enemy & Sons Ltd for reporting the vulnerability to us and helping verify the fix.

Ruby on Rails 2.3.9 Released on 4th September 2010

2011-02-05T19:24:00.000+08:00

Posted by Jeremy Kemper September 04, 2010 @ 09:45 PM

We’ve released Ruby on Rails 2.3.9 (gem and git tag) to extend the 2.3.8 bridge a few steps closer to Rails 3 and Ruby 1.9. If your app runs on Rails 2.3.9 without deprecation warnings, you’re looking good for an upgrade to Rails 3.

Deprecations

Changes i18n named-interpolation syntax from the deprecated Hello {{name}} to the 1.9-native Hello %{name}.
Replaces Kernel#returning with Object#tap which is native to Ruby 1.8.7.
Renames Array#random_element to Array#sample which is native to Ruby 1.9.
Renames config.load_paths and .load_once_paths to the more accurate config.autoload_paths and .autoload_once_paths.

Along with these deprecations come a broad array of bugfixes and minor tweaks. Read the commit log for the full story.
Onward to 3.1!

Rails 3.0: It's ready!

2010-10-05T11:44:00.000+08:00

CCH : As posted by DHH on Riding Rails

Posted by David August 29, 2010 @ 06:28 PM

Rails 3.0 has been underway for a good two years, so it’s with immense pleasure that we can declare it’s finally here. We’ve brought the work of more than 1,600 contributors together to make everything better, faster, cleaner, and more beautiful.
This third generation of Rails has seen thousands of commits, so picking what to highlight was always going to be tough and incomplete. But here’s a choice selection of major changes for Rails 3:
New Active Record query engine
Active Record has adopted the ARel query engine to make scopes and queries more consistent and composable. This makes it much easier to build complex queries over several iterations. We also delay the actual execution of the query until it’s needed. Here’s a simple example:

users = User.where(:name => "david").limit(20)
users = users.where("age > 29")

# SELECT * FROM users 
# WHERE name = "david" AND age > 29 
# ORDER BY name
# LIMIT 20
users.order(:name).each { |user| puts user.name }

Read more in new Active Record guide and watch the Dive into Rails 3: ARel video.
New router for Action Controller
When we switched to a REST-based approach for controllers in Rails 2, we patched on the syntax to the existing router while we were waiting to see if the experiment panned out.
It did and for Rails 3 we’ve gone back and revamped the syntax completely to favor the REST style with less noise and more flexibility:

resources :people do
  resource :avatar

  collection do
    get :winners, :losers
  end
end

# /sd34fgh/rooms
scope ':token', :token => /\w{5,5}/ do
  resources :rooms
end

# /descriptions
# /pl/descriptions
# /en/descriptions
scope '(:locale)', :locale => /en|pl/ do
  resources :descriptions
  root :to => 'projects#index'
end

Read more in the new routing guide.
New Action Mailer
Action Mailer was born with a split-personality of half model, half controller. In Rails 3, we’ve made the choice to make it all controller. This means that the feel and functionality will be much closer to Action Controller and in fact they now share a bunch of underlying code. Here’s a taste of what it looks like now:

class Notifier < ActionMailer::Base
  default :from =>
    "Highrise " 

  def new_project(digest, project, person)
    @digest, @project, @person = digest, project, person

    attachments['digest.pdf'] = digest.to_pdf
    attachments['logo.jpg']   = File.read(project.logo_path)

    mail(
      :subject => "Your digest for #{project.name}",
      :to => person.email_address_with_name
    ) do |format|
      format.text { render :text => "Something texty" }
      format.html { render :text => "Something texty" }
    end
  end
end

The new Action Mailer is built on top of the new Mail gem as well. Say goodbye to TMail headaches.
Read more in new Action Mailer guide.
Manage dependencies with Bundler
Managing all the dependencies of a Rails application has long been a hassle of patchworks. We had config.gem, Capistrano externals, custom rake setup tasks, and other incomplete solutions.
Bundler cleans all that up and allows you to specify the libraries, frameworks, and plugins that your application depends on. All Rails 3 applications are born with a Gemfile to control it all. See more on the Bundler site.
XSS protection by default
The internet is a scary place and Rails 3 is watching out for you by default. We’ve had CRSF protection with form signing for a while and SQL-injection protection since the beginning, but Rails 3 ups the anté with XSS protection as well (hat tip to Django for convincing us).
See the Railscast on XSS video and the Dive into Rails 3: Cross-site scripting video for more.
Say goodbye to encoding issues
If you browse the Internet with any frequency, you will likely encounter the � character. This problem is extremely pervasive, and is caused by mixing and matching content with different encodings.
In a system like Rails, content comes from the database, your templates, your source files, and from the user. Ruby 1.9 gives us the raw tools to eliminate these problems, and in combination with Rails 3, � should be a thing of the past in Rails applications. Never struggle with corrupted data pasted by a user from Microsoft Word again!
Active Model: Validations, callbacks, etc for all models
We’ve extracted quite a bit of commonly requested Active Record components into the new Active Model framework. This allows an ORM like Mongoid to use Active Record’s validations, callbacks, serialization, and i18n support.
Additionally, in the rewrite of Action Controller, we removed any direct references to Active Record, defining a clean, simple API that ORMs can implement. If you use an API-compliant ORM (like DataMapper, Sequel, or Mongoid), you will be able to use features like form_for, link_to and redirect_to with objects from those ORMs without any additional work.
Official plugin APIs
We also rewrote Railties with the express goal of using the new plugin API for all Rails frameworks like Active Record and Action Mailer. This means that Rails plugins like the ones for DataMapper and RSpec have access to all of the integration as the built-in support for Active Record and Test::Unit.
The new Railtie API makes it possible to modify the built-in generators, add rake tasks, configure default Rails options, and specify code to run as early, or as late as you need. Rails plugins like Devise were able to add much better integration in the Rails 3 version of their plugin. Expect to see a lot more of that in the months ahead.
Rewritten internals
We rewrote the internals of Action Pack and Railties, making them much more flexible and easier to extend. Instead of a single monolithic ActionController::Base, Rails 3 exposes a number of modules, each with defined APIs, that you can mix and match to create special-purpose controllers for your own use. Both Action Mailer in Rails and the Cells project make heavy use of this new functionality.
You can also take a look a this blog post by Yehuda (from last year) to see how the new architecture makes it easy to implement Django-style generic actions in Rails by leveraging Rack and ActionController::Metal.
The Rails generator system is got a revamp as well. Instead of monolithic generators that know about all of the Rails frameworks, each generator calls a series of hooks, such as :test_framework and :orm, that plugins can register handlers for. This means that generating a scaffold when using rSpec, DataMapper and Haml will generate a scaffold customized for those plugins.
Agnosticism with jQuery, rSpec, and Data Mapper
The rewritten internals and the new plugin APIs have brought true agnosticism to Rails 3 for all components of the framework. Prefer DataMapper to Active Record? No problem. Want to use jQuery instead of Prototype? Go ahead. Eager to test with rSpec instead of test/unit? You got it.
It’s never been easier to Have It Your Way™ with Rails 3. And at the same time, we’ve made that happen without making using the excellent default stack any more complicated.
Documentation
Rails 3 has had a long development cycle and while that might have lead to some impatience, it has also given book and tutorial authors a chance to catch up and be ready. There’s a wealth of great Rails 3 documentation available already and more is coming shortly.
The Agile Web Development with Rails 4th Ed book is almost ready and there are plenty more books coming. Check out all the new guides, the new official videos, new Railscasts, and a new tutorial. See the recent recap of documentation sources for more.
Installation
gem install rails --version 3.0.0. We also have a Rails v3.0.0 tag and a 3-0-stable branch.
Rails 3.0 has been designed to work with Ruby 1.8.7, Ruby 1.9.2, and JRuby 1.5.2+.
Gratitude and next steps
I’m personally incredibly proud of this release. I’ve been working on Rails for more than 7 years and the quality of the framework we have today is just astounding. This is only possible as a community effort and Rails 3 has seen so many incredible developers step up and help make this our best release ever (wink). Many thanks to all of you.
We’ll continue to develop Rails 3.0 with fixes and tweaks via the stable branch and Rails 3.1 is already cooking on master.
UPDATE: We’re raising money for Charity:Water in the name of Rails 3.0. Please donate and help us bring clean water to 5,000 people in the name of the Rails community.

Ruby on Rails 2.39 Released on 4th September 2010

2010-10-05T11:41:00.001+08:00

CCH : As posted on Riding Rails

Posted by Jeremy Kemper September 04, 2010 @ 09:45 PM

Deprecations

Changes i18n named-interpolation syntax from the deprecated Hello {{name}} to the 1.9-native Hello %{name}.
Replaces Kernel#returning with Object#tap which is native to Ruby 1.8.7.
Renames Array#random_element to Array#sample which is native to Ruby 1.9.
Renames config.load_paths and .load_once_paths to the more accurate config.autoload_paths and .autoload_once_paths.

Along with these deprecations come a broad array of bugfixes and minor tweaks. Read the commit log for the full story.
Onward to 3.1!

Ruby on Rails Version 2.3.8 released on 25th May 2010

2010-06-10T19:38:00.003+08:00

CCH : An update from Riding Rails

The 2.3.7 release slipped out the door too hastily. Fixing compatibility with the rails_xss plugin inadvertently forced everyone to use it. Facepalm.

I apologize for wasting a chunk of your day on installing what ought to have been a patch-level update only to find it breaks your app. That’s well out of line with our stable release process and it’s my fault for stepping out of it. I got caught up in a sky-is-falling response to a 2.3.6 bug that affected a handful of users and responded with a fix that exposed a new flaw to nearly all users, despite testing and sanity checking.

Thanks for all your feedback today. We hear you, and yes, a thousand times yes. Every stable release, including point releases, deserves the same methodical drumbeat on its march from git stable to to .pre gem to final gem. Expect no less.

Now, on to the gem-cutting: Rails 2.3.8 is available now, bringing us back to stable ground.

Ruby on Rails Version 2.3.7 released on 23rd May 2010

2010-06-10T19:37:00.001+08:00

CCH : Update from Riding Rails

With the 2.3.6 release hot out of the oven, Nathan Weizenbaum began updating HAML to support it.

He uncovered a couple of bugs in the HTML-safety changes backported from Rails 3, so we’re cutting a 2.3.7 release to fix them.

If you use the rails_xss plugin for automatic HTML escaping, you should upgrade to Rails 2.3.7 and the latest rails_xss plugin.

If you don’t use the rails_xss plugin yet, now’s the time to start. It’s baked in to Rails 3.
Update: fixing compatibility with the rails_xss plugin broke HTML-safety for apps that don’t use rails_xss. We’re sorry, all: HTML-safety is meant to be opt-in! The fix is available now in 2.3.8.pre1 and will be released shortly.

Ruby on Rails Version 2.3.6 released on 23rd May 2010

2010-06-08T18:28:00.000+08:00

CCH : Ruby on Rails Version 2.3.6 released on 23rd May 2010

We’ve released Ruby on Rails 2.3.6: six months of bug fixes, a handful of new features, and a strong bridge to Rails 3.
We deprecated some obscure and ancient features in Rails 2.3.6 so we could cut them entirely from Rails 3. If your app runs on Rails 2.3.6 without deprecation warnings, you’re in good shape for a smooth sail onward.
This slow-cooked dish is brought to you some 87 committers from our all-volunteer kitchen.
Now, let’s open the goodie bag!

Action Pack

Upgrade Rack from 1.0.1 to 1.1.0.
XSS prevention: update to match Rails 3 and move to the official plugin at http://github.com/rails/rails_xss.
Cookies: convenient cookie jar add-ons to set permanent or signed cookies, or both at once: cookies.permanent.signed[:remember_me] = current_user.id. Read more.
Flash: promote alert and notice, the most common flash keys in many apps, to self.alert = '...' and self.notice = '...'. Add redirect_to url, :alert => '...' and :notice => '...'. Read more.
i18n: localize the label helper.

Active Record

Namespacing: support optional table name prefixes on modules by defining self.table_name_prefix. Read more.
Destroy uses optimistic locking.
Counter cache: use Post.reset_counters(1234, :comments) to count the number of comments for post 1234 and reset its comments_count cache.
PostgreSQL: always use standard-conforming strings, if supported.
MySQL: add index length support. Read more.
MySQL: add_ and change_column support column positioning using :first => true and :after => :other_column.

Active Support

Upgrade i18n from 1.3.3 to 1.3.7.
Upgrade TZInfo from 0.3.12 to 0.3.16.
Multibyte: speed up string verification and cleaning.
JSON: use YAJL for JSON decoding, if available. gem install yajl-ruby
Testing: add assert_blank and assert_present. Read more.
Core: backport Object#singleton_class from Ruby 1.8.8, deprecating our Object#metaclass.
Core: add Object#presence that returns the object if it’s #present? otherwise returns nil. Example: region = params[:state].presence || params[:country].presence || 'US'
Core: add Enumerable#exclude? to match include?.
Core: rename Array#rand to Array#random_element to avoid collision with Kernel#rand.
Core: rename Date# and Time#last_(month|year) to #prev_(month|year) for Ruby 1.9 forward compatibility.

Active Resource

JSON: set ActiveResource::Base.include_root_in_json = true to serialize as a hash of model name -> attributes instead of a bare attributes hash. Defaults to false.

Action Mailer

Upgrade TMail from 1.2.3 to 1.2.7.

Railties

Silence RubyGems 1.3.6 deprecation warnings.

Rails 3 Beta Release on 5th February 2010

2010-02-13T18:45:00.001+08:00

Posted by David HH February 05, 2010 @ 03:33 AM on Riding Rails

You thought we were never going to get to this day, didn’t you? Ye of little faith. Because here is the first real, public release of Rails 3.0 in the form of a beta package that we’ve toiled long and hard over.
It’s surely not perfect yet, but we were out of blockers on the list, so here we go. Please give it a run around the block, try to update some old applications, try to start some new ones, and report back all the issues you find.
I’m really proud of this moment, actually. We’ve had more than 250 people help with the release and we’ve been through almost 4,000 commits since 2.3 to get here. Yet still the new version feels lighter, more agile, and easier to understand. It’s a great day to be a Rails developer.
There’s plenty to get excited about here. A few of the headliner features are:

Brand new router with an emphasis on RESTful declarations
New Action Mailer API modelled after Action Controller (now without the agonizing pain of sending multipart messages!)
New Active Record chainable query language built on top of relational algebra
Unobtrusive JavaScript helpers with drivers for Prototype, jQuery, and more coming (end of inline JS)
Explicit dependency management with Bundler

But please take a look at the full release notes and enjoy the latest!
To install:

gem install tzinfo builder memcache-client rack rack-test rack-mount erubis mail text-format thor bundler i18n
gem install rails --pre

Ruby on Rails 2.3.5 Released on 30th November 2009

2009-12-14T13:53:00.000+08:00

CCH : From Riding Rails

Ruby on Rails 2.3.5 Released

Posted by Gregg Pollack November 30, 2009 @ 07:58 PM

Rails 2.3.5 was released over the weekend which provides several bug-fixes and one security fix. It should be fully compatible with all prior 2.3.x releases and can be easily upgraded to with “gem update rails”. The most interesting bits can be summarized in three points.

Improved compatibility with Ruby 1.9
There were a few small bugs preventing full compatibility with Ruby 1.9. However, we wouldn’t be surprised you were already running Rails 2.3.X successfully before these bugs were fixed (they were small).

RailsXss plugin availability
As you may have heard, in Rails 3 we are now automatically escaping all string content in erb (where as before you needed to use “h()” to escape). If you want to have this functionality today you can install Koz’s RailsXss plugin in Rails 2.3.5.

Fixes for the Nokogiri backend for XmlMini
With Rails 2.3 we were given the ability to switch out the default XML parser from REXML to other faster parsers like Nokogiri. There were a few issues with using Nokogiri which are now resolved, so if your application is parsing lots of xml you may want to switch to this faster XML parser.

And that’s the gist of it
Feel free to browse through the commit history if you’d like to see what else has been fixed (but it’s mostly small stuff).

What's New in Edge Rails - 12th October 2009

2009-11-01T12:57:00.000+08:00

CCH : From Riding Rails

So, Edge Rails is still chugging right along. There are new and interesting fixes, changes, and refactors going on all of the time. So, lets take a look at just a few that've gone in since the last post (it's been a while, I know, I'm sorry!).
ActionView and Helpers

XSS escaping is now enabled by default. This means that if you want to explicitly output HTML to your views, you'll probably have to mark it as html_safe! before sending it through.

<%= 'my safe string'.html_safe! %>

Many of the built-in helpers have been updated for this change and if you see an issues with the Rails helpers being incorrectly sanitized, you should create a new ticket.

distance_of_time_in_words has gained 'over', 'about', and 'almost' keywords, thanks to Jay Pignata and John Trupiano. This provides you with an improved level of granularity when approximating the amount time passed. So, instead of just "2 years ago", it can now also report "almost 2 years ago," "about 2 years ago," and "over 2 years ago," depending on the proximity to being exactly 2 years old.

assert_equal "almost 2 years", distance_of_time_in_words(from, to + 2.years - 3.months + 1.day)
assert_equal "about 2 years",   distance_of_time_in_words(from, to + 2.years + 3.months - 1.day)
assert_equal "over 2 years",    distance_of_time_in_words(from, to + 2.years + 3.months + 1.day)
assert_equal "over 2 years",    distance_of_time_in_words(from, to + 2.years + 9.months - 1.day)
assert_equal "almost 3 years", distance_of_time_in_words(from, to + 2.years + 9.months + 1.day)

The HTML form helper, fields_for - generally used for nesting additional model forms - now allows for explicit collections to be used, thanks to Andrew France. So, instead of just including all of your blog.posts, you should have it only display your published blog.posts, for example. Or:

<% form_for @person, :url => { :action => "update" } do |person_form| %>
...
<% person_form.fields_for :projects, @active_projects do |project_fields| %>
    Name: <%= project_fields.text_field :name %>
<% end %>
<% end %>

API Change for content_tag_for: The third argument - being the optional CSS prefix - will now also affect the generated CSS class. This prefix will now be appended to the generated element's CLASS attribute.

<%= content_tag_for(:li, @post, :published) %>
# =>

...

ActiveResource and ActiveRecord

Taryn East has added update_attribute(s) methods to ActiveResource. These methods act very similarly to the ActiveRecord methods we already know and love.

Building or creating an object through a has_one association that contains conditionals will now automatically append those conditions to the newly created object, thanks to Luciano Panaro.

class Blog
has_author :commit_author, :class_name => 'Author', :conditions => {:name => "Luciano Panaro"}
end

@blog.build_commit_author
# => #

Pratik Naik added a new option to ActiveRecord's accepts_nested_attributes_for to :limit the number of records that are allowed to be processed. Also, while we're covering accepts_nested_attributes_for, José Valim as renamed the _delete option to _destroy to better follow what is actually occurring. A deprecation warning has been added to _delete, for the time being.

Jacob Burkhart updated the new autosave option in Rails 2.3 to allow for an :autosave => false, which will disallow saving of associated objects, even when they are new_record?s.
Some Internals

Previously, CDATA elements could be ignored when converting from XML to a Hash, so now, thanks to John Pignata, Hash#from_xml will now properly parse and include CDATA elements values.

Josh Peek has relocated global exception handling into ActionDispatch::Rescue. So, this is now being handled at the Rack middleware level.

And finally, Yehuda Katz and Carl Lerche began work on a Rails::Application object to better encapsulate some of the application start up and configuration details. Also, a good bit of initialization has now gone on to move into this new object.

Remember, if you prefer to have a shorter audio summary of some of this content and more, you should check out the Ruby5 podcast over at Envy Labs; it's released every Tuesday and Friday with the latest news in the Ruby and Rails community.

Photo: Clock Tower by Brian Taylor

Posted in Edge | 17 comments

What's New in Edge Rails ?

2009-10-03T15:01:00.005+08:00

CCH : From the Riding Rails Blog

Posted by Nathaniel Bibler September 06, 2009 @ 05:07 PM

It's been a bit over two weeks since the last WNiER ("winner"?) post and in the time since our last visit, Ruby on Rails 2.3.4 was released to fix some reported security issues. It is important that you try to upgrade your applications as soon as possible, or even just apply the provided patches if a full upgrade isn't easily accomplished in your situation.
Along with this release, you're also going to see several bug fixes and enhancements to the Rails framework, coming from many contributors, that have been discussed here over the previous weeks and even a few that are mentioned just below.

Security updates

Michael Koziarski posted fixes (here and here) for cleaning and verifying multibyte (unicode) strings. The problem was reported by Brian Mastenbrook and Manfred Stienstra provided input for the fix. These changes should disallow malformed unicode strings from getting past the HTML escaping logic provided by the form helpers.
Coda Hale reported and also added a patch to Rails, fixing a timing attack vulnerability in ActiveSupport::MessageVerifier. Although not likely to be exploited in the wild, the vulnerability may allow an attacker to forge the signatures which encode your application's cookie store. If successfully broken, an attacker could modify their session objects without altering your application to the change.
There have been some issues reported around the Rails 2.3.4 release, specifically with regard to Ruby 1.9 support. While they have not all yet been fully substantiated, this certainly underscores the importance of having proper test coverage and both a staging and production environment for your applications.

Down to the metal

Yehuda Katz and Carl Lerche put in quite a bit of work around ActionController::Metal and Rack's Middleware, recently. ActionController::Metal now acts as a Rack middleware and at the same time, there is a new ActionController::Middleware class that operates as normal Rack middleware.
And, if that wasn't enough, Yehuda went on to add ActiveModel::Lint. ActiveModel::Lint allows you to determine whether or not an object is compliant with the ActiveModel API, via:

    ActiveModel::Compliance.test(object)

The output is similar to a Test::Unit output and will indicate with which portions of the ActiveModel API the given object is - or more importantly is not - compliant.
If Metal is your thing, you may want to take a look at Yehuda Katz's recent blog post, How to Build Sinatra on Rails 3.

Pour some sugar on me

Quite a few changes, small and large, occurred around ActiveRecord and friends. Most of these cleaned up some existing functionality, either making it easier to use, perform more closely to what would be expected, or even adding some new features that will soon feel like old friends.
Taryn East added a little ActiveRecord-like love to ActiveResource. In this patch, ActiveResource received the familiar first, last, and all shortcut methods for wrapping the basic find method.
Proc and symbol support was added to the validates_numericality_of ActiveRecord validation, by Kane.
For those of you who use the :anchor option when generating URLs, you may notice that after this patch by Jeffrey Hardy, Rails will now execute the to_param method on the object provided as an :anchor.

    @post       = Post.first
    @comment    = Comment.first
    post_url(@post, :anchor => @comment) # => http://www.example.com/posts/1#comment-1

Well, something similar to that, anyway. :) This updates the :anchor options to follow a similar functionality as the other options provided when generating URLs.
José Valim cleaned up some bits in the Rails scaffold. The generated new and edit views will now reference a new _form partial. This is a much DRYer way to go about it, and more closely follows what would likely happen if you were to code it yourself. Also, while he was there, he removed a bit of inline CSS (specifically, a green flash message), in favor of a CSS class and updating the default scaffold stylesheet.
And, probably the most interesting change in this group is the addition of a new ActivRecord#previous_changes method, by Scott Barr. previous_changes allows you to see what changed before the last save in your local ActiveRecord object instance. This is particularly useful when calling after_save methods which might need to know what exactly had changed. I'll let him give you a code sample:

    person          = Person.find_by_name('bob')
  person.name = 'robert'
  person.changes                        # => {'name' => ['bob, 'robert']}
  person.save
  person.changes                        # => {}
  person.previous_changes   # => {'name' => ['bob, 'robert']}
  person.reload
  person.previous_changes   # => {}

Okay, let's do it your way

While a lot of us prefer US English, we (begrudgingly) recognize that we aren't always the center of the universe. As such, there are some more localization updates to report in Edge Rails:
Sven Fuchs added localization support to the ActiveRecord::RecordInvalid exception's error message. Then, Akira Matsuda followed Sven with support for localizing the SELECT tag helper's prompt text (the default being, "Please select").
Finally, this is certainly a welcome addition and potentially a major player in localization support within Rails: Antonio Tapiador del Dujo added a patch which allows Rails plugins to define and maintain their own locale files. All that is necessary for the plugin developer to do is to provide a config/locales/ directory within their plugin and then create their own .rb or .yml files (i.e. en.yml). That means that plugins can now be much more responsible for their own localization support and do not have to modify the application's locale files after installation.

Food for thought

Finally, just a small note that the default, preferred table collation for MySQL has been changed. Previously, Rails defaulted to utf8_general_ci when either the database or the table creation script did not dictate otherwise. Now, that has been changed to utf8_unicode_ci. Certainly worth a note with so many Rails applications using MySQL in their back-end.
Update: Set the attribution of previous_changes to Scott Barr. Sorry, Scott!

Ubuntu 9.04 : Upgrading from Rails 2.3.3 to Rails 2.3.4

2009-09-06T21:15:00.002+08:00

This is how I have upgraded Rails 2.3.3 to Rails 2.3.4 in Ubuntu 9.04

chee@ibm4linux:~$ sudo gem install rails
[sudo] password for chee:
Successfully installed activesupport-2.3.4
Successfully installed activerecord-2.3.4
Successfully installed actionpack-2.3.4
Successfully installed actionmailer-2.3.4
Successfully installed activeresource-2.3.4
Successfully installed rails-2.3.4
6 gems installed
Installing ri documentation for activesupport-2.3.4...
Installing ri documentation for activerecord-2.3.4...
Installing ri documentation for actionpack-2.3.4...
Installing ri documentation for actionmailer-2.3.4...
Installing ri documentation for activeresource-2.3.4...
Installing ri documentation for rails-2.3.4...
Installing RDoc documentation for activesupport-2.3.4...
Installing RDoc documentation for activerecord-2.3.4...
Installing RDoc documentation for actionpack-2.3.4...
Installing RDoc documentation for actionmailer-2.3.4...
Installing RDoc documentation for activeresource-2.3.4...
Installing RDoc documentation for rails-2.3.4...

Announcement : Rails 2.3.4 is released on 4th Sept 2009

2009-09-06T21:13:00.000+08:00

The Rails Team has just announced the release of Rails 2.3.4 as follows :-

We’ve released Ruby on Rails 2.3.4, this release fixes bugs and introduces a few minor features. Due to the inclusion of two security fixes, all users of the 2.3 series are recommended to upgrade as soon as possible.

Security Fixes

2.3.4 contains fixes for two security issues which were reported to us. For more details see the security announcements:

Bug Fixes

Thanks to the success of the BugMash we have around 100 bug fixes as part of this release. Of particular not is the fix to reloading problems related to rack middleware and rails metals when running in development mode.

New Features

Support for bundling I18n translations in plugins, Rails will now automatically add locale files found in any engine’s locale directory to the I18n.load_path. commit
Added db/seeds.rb as a default file for storing seed data for the database. Can be loaded with rake db:seed commit

Rails Basics : link_to

2009-09-06T12:18:00.004+08:00

It is an almost Rails convention that you should use Ruby code rather than HTML to create links as a mater of style and flexibility via routes.rb

link_to is an example of a Rails function for html generation and is typically used to add site-wide navigation. For example,

   <%= link_to('Home',       { :action = 'index'}) %> |
   <%= link_to('About Us', { :action ='about'}) %>

You may be interested to note that curly braces are optional in hashes where they are the final argument to a function as follows :-

   <%= link_to('About Us',:action ='about') %>

How does one not link to a page that is currently displayed ?

   <%= link_to_unless_current('Home',       { :action = 'index'}) %> |
   <%= link_to_unless_current('About Us', { :action ='about'}) %>

Are there other related link_to functions ?

Rails adheres to a naming convention whereby a group of related functions have related names, usually of the form original_function_name and original_function_name_with_modification

Let's check to the Rails API via the Rails API Tab in Aptana Radrails or at http://api.rubyonrails.org and this is what you should find

link_to
link_to_if
link_to_remote
link_to_unless
link_to_unless_current

How to display an image inside a link_to

<%= link_to image_tag("about.gif", :border=>0), :action => 'about' %>

Rail Basics : What happens when you script/generate ?

2009-09-02T00:06:00.001+08:00

chee@ibm4linux:~/workspace/crm4test$ script/generate

Usage: script/generate generator [options] [args]
Rails Info:
    -v, --version                    Show the Rails version number and quit.
    -h, --help                       Show this help message and quit.
General Options:
    -p, --pretend                    Run but do not make any changes.
    -f, --force                      Overwrite files that already exist.
    -s, --skip                       Skip files that already exist.
    -q, --quiet                      Suppress normal output.
    -t, --backtrace                  Debugging: show backtrace on errors.
    -c, --svn                        Modify files with subversion. (Note: svn must be in path)
    -g, --git                        Modify files with git. (Note: git must be in path)

Installed Generators
Plugins (vendor/plugins): authenticated, roles
Builtin: controller, helper, integration_test, mailer, metal, migration, model, observer, performance_test, plugin, resource, scaffold, session_migration

More are available at http://wiki.rubyonrails.org/rails/pages/AvailableGenerators
1. Download, for example, login_generator.zip
2. Unzip to directory /home/chee/.rails/generators/login
     to use the generator with all your Rails apps
     or to /home/chee/workspace/crm4test/lib/generators/login
     to use with this app only.
3. Run generate with no arguments for usage information
       script/generate login

Generator gems are also available:
1. gem search -r generator
2. gem install login_generator
3. script/generate login

Rails Basics : What happens when you script/generate model ?

2009-09-02T00:00:00.001+08:00

chee@ibm4linux:~/workspace/crm4test$ script/generate model

Usage: script/generate model ModelName [field:type, field:type]
Options:
        --skip-timestamps            Don't add timestamps to the migration file for this model
        --skip-migration             Don't generate a migration file for this model
        --skip-fixture               Don't generation a fixture file for this model
Rails Info:
    -v, --version                    Show the Rails version number and quit.
    -h, --help                       Show this help message and quit.
General Options:
    -p, --pretend                    Run but do not make any changes.
    -f, --force                      Overwrite files that already exist.
    -s, --skip                       Skip files that already exist.
    -q, --quiet                      Suppress normal output.
    -t, --backtrace                  Debugging: show backtrace on errors.
    -c, --svn                        Modify files with subversion. (Note: svn must be in path)
    -g, --git                        Modify files with git. (Note: git must be in path)

Description:
    Stubs out a new model. Pass the model name, either CamelCased or
    under_scored, and an optional list of attribute pairs as arguments.

    Attribute pairs are column_name:sql_type arguments specifying the
    model's attributes. Timestamps are added by default, so you don't have to
    specify them by hand as 'created_at:datetime updated_at:datetime'.

    You don't have to think up every attribute up front, but it helps to
    sketch out a few so you can start working with the model immediately.

    This generates a model class in app/models, a unit test in test/unit,
    a test fixture in test/fixtures/singular_name.yml, and a migration in
    db/migrate.

Examples:
    `./script/generate model account`

        creates an Account model, test, fixture, and migration:
            Model:      app/models/account.rb
            Test:       test/unit/account_test.rb
            Fixtures:   test/fixtures/accounts.yml
            Migration: db/migrate/XXX_add_accounts.rb

    `./script/generate model post title:string body:text published:boolean`

        creates a Post model with a string title, text body, and published flag.

Rails Plugins : How to Install role_requirement ?

2009-08-31T12:19:00.003+08:00

Step 1 - Grab role_requirement form github.com

chee@ibm4linux:~/workspace/crm4test$ script/plugin install git://github.com/timcharper/role_requirement.git

Result

Initialized empty Git repository in /home/chee/workspace/crm4test/vendor/plugins/role_requirement/.git/
remote: Counting objects: 32, done.
remote: Compressing objects: 100% (30/30), done.
remote: Total 32 (delta 3), reused 10 (delta 0)
Unpacking objects: 100% (32/32), done.
From git://github.com/timcharper/role_requirement
* branch            HEAD       -> FETCH_HEAD

Step 2 - Run the generator

chee@ibm4linux:~/workspace/crm4test$ script/generate roles Role User

Generating Role against User
Added the following to the top of app/models/user.rb:

# ---------------------------------------
# The following code has been generated by role_requirement.
# You may wish to modify it to suit your need
has_and_belongs_to_many :roles

# has_role? simply needs to return true or false whether a user has a role or not.
# It may be a good idea to have "admin" roles return true always
def has_role?(role_in_question)
    @_list ||= self.roles.collect(&:name)
    return true if @_list.include?("admin")
    (@_list.include?(role_in_question.to_s) )
end
# ---------------------------------------

Added ApplicationController include to /home/chee/workspace/crm4test/app/controllers/application_controller.rb
Added RoleRequirement include to /home/chee/workspace/crm4test/app/controllers/application_controller.rb
      create test/fixtures/roles.yml
      create app/models/role.rb
      create lib/role_requirement_system.rb
      create lib/role_requirement_test_helper.rb
      create lib/hijacker.rb
      exists db/migrate
      create db/migrate/20090831042625_create_roles.rb

Step 3 - rake db:migrate

chee@ibm4linux:~/workspace/crm4test$ rake db:migrate
(in /home/chee/workspace/crm4test)
== CreateRoles: migrating ====================================================
-- create_table("roles")
   -> 0.0037s
-- create_table("roles_users", {:id=>false})
   -> 0.0027s
-- add_index("roles_users", "role_id")
   -> 0.0122s
-- add_index("roles_users", "user_id")
   -> 0.0016s
== CreateRoles: migrated (0.0229s) ===========================================

What does the Generators do ?

Only if many roles are used:

Generates habtm table, creates role.rb with the habtm declaration. Adds declaration in user.rb (scans the code for "class User < ActiveRecord::Base", and puts the new code right after it.
Creates an admin user in users.yml, with a role named admin in roles.yml, including a fixture to demonstrate how to relate roles to users in roles_users.yml

Modify the user.rb (or corresponding user model) file, add the instance method has_role?

Generates RoleRequirementSystem against for the corresponding user model.

Generates a migration to make the necessary database changes

Scans ApplicationController, inserts the lines "include AuthenticatedSystem", and "include RoleRequirementSystem", if not already included.

Scans test_helper.rb and adds "includes RoleRequirementTestHelpers", if not already included.

Rails Plugins : How to Install restful_authentication ?

2009-08-31T11:50:00.003+08:00

To use role_requirement, the prerequisite is to install the restful_authentication plugin. These are the 3 steps that I took to achieve a succesful installation.

Step 1 - Grab the plugin from github.com

chee@ibm4linux:~/workspace/crm4test$ script/plugin install git://github.com/technoweenie/restful-authentication.git

Result

Initialized empty Git repository in /home/chee/workspace/crm4test/vendor/plugins/restful-authentication/.git/
remote: Counting objects: 89, done.
remote: Compressing objects: 100% (77/77), done.
remote: Total 89 (delta 5), reused 31 (delta 2)
Unpacking objects: 100% (89/89), done.
From git://github.com/technoweenie/restful-authentication
* branch            HEAD       -> FETCH_HEAD

Step 2 - Generate user and sessions controllers

chee@ibm4linux:~/workspace/crm4test$ script/generate authenticated user sessions

This is what you will see in the command line editor (in Ubuntu 9.04, a Gnome Terminal Window)

Ready to generate.
----------------------------------------------------------------------
Once finished, don't forget to:

- Add routes to these resources. In config/routes.rb, insert routes like:
    map.signup '/signup', :controller => 'users', :action => 'new'
    map.login '/login', :controller => 'sessions', :action => 'new'
    map.logout '/logout', :controller => 'sessions', :action => 'destroy'

CCH : No need to do so as the latest version automatically includes these routes to routes.rb
----------------------------------------------------------------------

We've create a new site key in config/initializers/site_keys.rb. If you have existing
user accounts their passwords will no longer work (see README). As always,
keep this file safe but don't post it in public.

----------------------------------------------------------------------
      exists app/models/
      exists app/controllers/
      exists app/controllers/
      exists app/helpers/
      create app/views/sessions
      exists app/controllers/
      exists app/helpers/
      create app/views/users
      exists config/initializers
      exists test/functional/
      exists test/functional/
      exists test/unit/
      exists test/fixtures/
      create app/models/user.rb
      create app/controllers/sessions_controller.rb
      create app/controllers/users_controller.rb
      create lib/authenticated_system.rb
      create lib/authenticated_test_helper.rb
      create config/initializers/site_keys.rb
      create test/functional/sessions_controller_test.rb
      create test/functional/users_controller_test.rb
      create test/unit/user_test.rb
      create test/fixtures/users.yml
      create app/helpers/sessions_helper.rb
      create app/helpers/users_helper.rb
      create app/views/sessions/new.html.erb
      create app/views/users/new.html.erb
      create app/views/users/_user_bar.html.erb
      exists db/migrate
      create db/migrate/20090831032706_create_users.rb
       route map.resource :session
       route map.resources :users
       route map.signup '/signup', :controller => 'users', :action => 'new'
       route map.register '/register', :controller => 'users', :action => 'create'
       route map.login '/login', :controller => 'sessions', :action => 'new'
       route map.logout '/logout', :controller => 'sessions', :action => 'destroy'

Step 3 - Modify the Project Database

chee@ibm4linux:~/workspace/crm4test$ rake db:migrate
(in /home/chee/workspace/crm4test)
== CreateUsers: migrating ====================================================
-- create_table("users", {:force=>true})
   -> 0.0074s
-- add_index(:users, :login, {:unique=>true})
   -> 0.0374s
== CreateUsers: migrated (0.0464s) ===========================================

You may be interested to look at the contents of the migration file as follows :-

class CreateUsers < ActiveRecord::Migration
def self.up
    create_table "users", :force => true do |t|
      t.column :login, :string, :limit => 40
      t.column :name, :string, :limit => 100, :default => '', :null => true
      t.column :email, :string, :limit => 100
      t.column :crypted_password,          :string, :limit => 40
      t.column :salt,     :string, :limit => 40
      t.column :created_at, :datetime
      t.column :updated_at, :datetime
      t.column :remember_token, :string, :limit => 40
      t.column :remember_token_expires_at, :datetime

    end
    add_index :users, :login, :unique => true
end

def self.down
    drop_table "users"
end
end

The Generated User & Sessions Controllers

User.rb

class UsersController < ApplicationController
# Be sure to include AuthenticationSystem in Application Controller instead
include AuthenticatedSystem

# render new.rhtml
def new
    @user = User.new
end

def create
    logout_keeping_session!
    @user = User.new(params[:user])
    success = @user && @user.save
    if success && @user.errors.empty?
            # Protects against session fixation attacks, causes request forgery
      # protection if visitor resubmits an earlier form using back
      # button. Uncomment if you understand the tradeoffs.
      # reset session
      self.current_user = @user # !! now logged in
      redirect_back_or_default('/')
      flash[:notice] = "Thanks for signing up! We're sending you an email with your activation code."
    else
      flash[:error] = "We couldn't set up that account, sorry. Please try again, or contact an admin (link is above)."
      render :action => 'new'
    end
end
end

sessions.rb

# This controller handles the login/logout function of the site.
class SessionsController < ApplicationController
# Be sure to include AuthenticationSystem in Application Controller instead
include AuthenticatedSystem

# render new.rhtml
def new
end

def create
    logout_keeping_session!
    user = User.authenticate(params[:login], params[:password])
    if user
      # Protects against session fixation attacks, causes request forgery
      # protection if user resubmits an earlier form using back
      # button. Uncomment if you understand the tradeoffs.
      # reset_session
      self.current_user = user
      new_cookie_flag = (params[:remember_me] == "1")
      handle_remember_cookie! new_cookie_flag
      redirect_back_or_default('/')
      flash[:notice] = "Logged in successfully"
    else
      note_failed_signin
      @login       = params[:login]
      @remember_me = params[:remember_me]
      render :action => 'new'
    end
end

def destroy
    logout_killing_session!
    flash[:notice] = "You have been logged out."
    redirect_back_or_default('/')
end

protected
# Track failed login attempts
def note_failed_signin
    flash[:error] = "Couldn't log you in as '#{params[:login]}'"
    logger.warn "Failed login for '#{params[:login]}' from #{request.remote_ip} at #{Time.now.utc}"
end
end

Rail Basics : What happens when you script/generate controller ?

2009-08-30T19:36:00.003+08:00

What do you think will happen if you script/generate controller ?

Why wonder, just do it :-)

If you are using Ubuntu 9.04, just open a Terminal Window and cd to the root of your Rails applications and type script/generate controller -- as follows :-

chee@ibm4linux:~/workspace/crm2009$ script/generate controller

After pressing Enter, this is what you will see.

Usage: script/generate controller ControllerName [options]
Rails Info:
    -v, --version                    Show the Rails version number and quit.
    -h, --help                       Show this help message and quit.
General Options:
    -p, --pretend                    Run but do not make any changes.
    -f, --force                      Overwrite files that already exist.
    -s, --skip                       Skip files that already exist.
    -q, --quiet                      Suppress normal output.
    -t, --backtrace                  Debugging: show backtrace on errors.
    -c, --svn                        Modify files with subversion. (Note: svn must be in path)
    -g, --git                        Modify files with git. (Note: git must be in path)

Description:
    Stubs out a new controller and its views. Pass the controller name, either
    CamelCased or under_scored, and a list of views as arguments.

    To create a controller within a module, specify the controller name as a
    path like 'parent_module/controller_name'.

    This generates a controller class in app/controllers, view templates in
    app/views/controller_name, a helper class in app/helpers, a functional
    test suite in test/functional and a helper test suite in test/unit/helpers.

Example:
    `./script/generate controller CreditCard open debit credit close`

    Credit card controller with URLs like /credit_card/debit.
        Controller:      app/controllers/credit_card_controller.rb
        Functional Test: test/functional/credit_card_controller_test.rb
        Views:           app/views/credit_card/debit.html.erb [...]
        Helper:          app/helpers/credit_card_helper.rb
        Helper Test:     test/unit/helpers/credit_card_helper_test.rb

Modules Example:
    `./script/generate controller 'admin/credit_card' suspend late_fee`

    Credit card admin controller with URLs /admin/credit_card/suspend.
        Controller:      app/controllers/admin/credit_card_controller.rb
        Functional Test: test/functional/admin/credit_card_controller_test.rb
        Views:           app/views/admin/credit_card/debit.html.erb [...]
        Helper:          app/helpers/admin/credit_card_helper.rb
        Helper Test:     test/unit/helpers/admin/credit_card_helper_test.rb

Rails Basics : How to Install a Plugin from the Command Line ?

2009-08-30T12:10:00.002+08:00

Although Aptana Radrails and other Rails IDE usually have a Rails Plugin Tab or its equivalent, I personally feel that it easier and more flexible to do so using the Command Line.

To do so in Ubuntu 9.04, click Applications/Accessories/Terminal to open a terminal window and cd to the root of your Rails Project as follows :-

chee@ibm4linux:~$ cd workspace
chee@ibm4linux:~/workspace$ cd crm2009

chee@ibm4linux:~/workspace/crm2009$ script/plugin install

To discover the various options available in script/plugin

chee@ibm4linux:~/workspace/crm2009$ script/plugin --
Unknown command:
Usage: plugin [OPTIONS] command
Rails plugin manager.
GENERAL OPTIONS
-r, --root=DIR                   Set an explicit rails app directory.
                                   Default: /home/chee/workspace/crm2009
-s, --source=URL1,URL2           Use the specified plugin repositories instead of the defaults.
-v, --verbose                    Turn on verbose output.
-h, --help                       Show this help message.
COMMANDS
discover   Discover plugin repositories.
list       List available plugins.
install    Install plugin(s) from known repositories or URLs.
update     Update installed plugins.
remove     Uninstall plugins.
source     Add a plugin source repository.
unsource   Remove a plugin repository.
sources    List currently configured plugin repositories.

EXAMPLES
Install a plugin:
    plugin install continuous_builder

Install a plugin from a subversion URL:
    plugin install http://dev.rubyonrails.com/svn/rails/plugins/continuous_builder

Install a plugin from a git URL:
    plugin install git://github.com/SomeGuy/my_awesome_plugin.git

Install a plugin and add a svn:externals entry to vendor/plugins
    plugin install -x continuous_builder

List all available plugins:
    plugin list

List plugins in the specified repository:
    plugin list --source=http://dev.rubyonrails.com/svn/rails/plugins/

Discover and prompt to add new repositories:
    plugin discover

Discover new repositories but just list them, don't add anything:
    plugin discover -l

Add a new repository to the source list:
    plugin source http://dev.rubyonrails.com/svn/rails/plugins/

Remove a repository from the source list:
    plugin unsource http://dev.rubyonrails.com/svn/rails/plugins/

Show currently configured repositories:
    plugin sources

Rails Basics : What is a Model ?

2009-08-29T18:20:00.004+08:00

What is a Model ?

The Model is the 'M' in the MVC (Model/Views/Controller) concept integral to a Rails application.

Models should :-

Constitute most of your application codes.
Provide a persistent storage mechanism to your database
Define all business logic

In a nutshell, Models should be the brains that operate on your application's database, determine and change the state of other objects and co-ordinate the overall business logic of your applications.

Conventions for Models

Model classes in Rails are all inherited from the ActiveRecord base class ActiveRecord::Base and map one-to-one to a table in your database.

Residing in the app/models directory, Models should following the following convention :-

Only one class per file
Class name should be singular and camel-cased eg.Customer or BillNo
Corresponding table name should be lowercased, plural and underscored eg. customers or bill_nos
Corresponding table must have an auto-incrementing integer field called id
Column names shoudl also be lowercased
Model filename should be lowercased and underscored version of the class name eg. customer.rb or bill_no.rb

To represent the relationship between tables and columns in your application, ActiveRecord provides the following set of methods called associations :-

has_many represents a zero-to-many relationship between the Parent & Child Class
belongs_to is the reciprocal child method to parent has_many method
has_one is like a belongs_to and represents a one-to-one relationship in your database

More to come...

Rails Basics : What is a Controller ?

2009-08-28T13:59:00.017+08:00

What is a Controller ?

The Controller is an integral component of the MVC (Model/View/Controller) concept that is central to Rails. Controllers are normal Ruby classes that inherit from ActionController:Base or more frequently the generated ApplicationController Class

Controllers have public action methods that can be called from the dispatcher as well as their own protected and private methods. Typically, action methods follow this pattern :-

Manipulate the domain model in some way
Refers to the response format requested by the user
Generate a response in the correct form by rendering a view template

Controllers are more closely linked to Views than Models in that you can work on a Model in your application before even creating a Controller. That is why script/generate controller will also automatically create helpers and views folders but not a model folder as follows :-

script/generate controller Concepts

exists app/controllers/

exists app/helpers/

create app/views/concepts

exists test/functional/

exists test/unit/helpers/

create app/controllers/concepts_controller.rb

create test/functional/concepts_controller_test.rb

create app/helpers/concepts_helper.rb

create test/unit/helpers/concepts_helper_test.rb

As such, you should remove all Business Logic from your Controllers and put in the corresponding Model.

So what does the Controllers in your Rails application do ?

Well, your controllers are only responsible for mapping between URLs, co-ordinating with your Models and your Views and channeling back to a HTTP response. In addition, it may do Access Control as well.

Basically, when someone connects to your Rails Application via an URL, they are ly asking your Application to execute a Controller Action. Typically, action methods follow this pattern :-

Interact with the domain model in some way such as selecting, inserting or updating data based on incoming parameters or using one or more classes form the app/model directory
Generate a response by rendering a view template with the same name as the action method

Controller Conventions
As you may be aware, Rails works magically so long as you adhere to the all important concepl of Convention over Configuration. In this respect Controller Conventions include :-

a) The Controller's class name should be camel cased and pluralised and be followed by the word controller. eg.CustomersControllers or BillNosControllers

b) Similar to Models, the controller filename should be lowercased and underscored versions of the class name. eg. customers_controllers.rb or bill_nos_controllers.rb

c) An action is a Public Method of a controller class. For example

index
show
new
create
edit
update
destroy

BTW, the above-mentioned actions are RESTful Rails actions. Each one of these methods connects the data in the Model layer to what you allow the user to see.

What is fascinating is that unless explicitly told to do , Rails will render the views with the same name as the actions!

How to remove a controller and all previously generated files ?

chee@ibm4linux:~/workspace/crm2009$ script/destroy controller concepts
          rm test/unit/helpers/concepts_helper_test.rb
          rm app/helpers/concepts_helper.rb
          rm test/functional/concepts_controller_test.rb
          rm app/controllers/concepts_controller.rb
    notempty test/unit/helpers
    notempty test/unit
    notempty test
    notempty test/functional
    notempty test
       rmdir app/views/concepts
    notempty app/views
    notempty app
    notempty app/helpers
    notempty app
    notempty app/controllers
    notempty app
chee@ibm4linux:~/workspace/crm2009$

Rails IDE : Installing Aptana Radrails 1.30 into Eclipse Galileo

2009-08-23T15:18:00.017+08:00

For Radrail users who would like to use it within Eclipse Galileo, you may want to follow this simple tutorial :-

1. Download Eclipse 3.50 aka Galileo

2. Launch Eclipse

3. Click Help/Install Software

4. Install Aptana Studio 1.5 as a plug into Eclipse

5. Install Aptana Radrails via Aptana Studio

6. Open Aptana Radrails Perspective via Windows/Open Perspective/Others

7. After opening a Rails Project

Migration : Migrating an Application from Rails 1.2.5 to Rails 2.3.3

2009-08-23T00:46:00.010+08:00

Since Nov 2007, I had a Rails 1.2 e-CRM application running on Windows Server 2003 and powered by Apache 2 and a pack of Mongrels web servers.

A couple of weeks ago, I discovered Ubuntu 9.04 and decided to migrate the e-CRM to Rails 2.3.3 running on Ubuntu 9.04.

What have I achieved thus far ?

1. Installing Rails 2.3.3 on Ubuntu 9.04
2. Installing Mongrel, Capistrano, Passenger and Apache on Ubuntu 9.04.
3. Installing Aptana Radrails on Ubuntu 9.04
4. Since Aptana Radrails was slow, I then installed Eclipse Ganymade (3.4.2) and managed to install the latest Aptana Radrails .1.30 as a plugin to Eclipse

When I attempted to run e-CRM on Rails 1.2, I ran into a number of incompatibilities including the need to update the following Rails Plugins

1. active_scaffold
2. active_scaffold_export
3. active_scaffold_tools (still unable to get a version compatible with Rails 2.3.3)
4. role_requirement
5. use restful_authentication instead of acts_as_authenticated
6. record_select
7. acts_as_audited

Then after wasting a couple of days, I discovered that Ubunti 9.04 being a Linux distro is case-sensitive and I had to pay attention to renaming the images files in the public\images folder.

Also, I used this script (command line) to auto-convert my rhtml files to html.erb as recommended for Rails 2.x

for f in $(find . -name '*.rhtml') ; do c=$(dirname $f)/$(basename $f .rhtml).html.erb ; mv $f $c ; done

Why the need to change rhtml to html.erb ?

Apparently in Rails 2.x, it’s been revealed that the .rhtml and .rxml file extensions will be deprecated in favor of .erb and .builder, respectively.
Why such a change – well, .rhtml files are not strictly html files. They are generic embedded ruby files that can be used for email templates, csv files, vcards etc… .erb is just a more generic, accurate extension for the file type. The same goes for .rxml – it can be used for more than just xml files. Think of all the rss feeds you’ve written with rxml files. Now you can stop being tied down by the limited .rxml file extension and can start using .builder.
FYI, the ‘old’ extensions won’t be fully deprecated until Rails 3.0.

BTW, this site was also useful reference in my quest to upgrade from Rails 1.2 to 2.3.3

Some additional plugins needed by active_scaffold include

a) in_place_editing - git://github.com/rails/in_place_editing.git
b) render_component

More to come...

Rails IDE: Can Radrails be installed into Eclipse ? {Updated 30th August 2009]

2009-08-22T21:00:00.009+08:00

I would answer Yes and No this question :-)

Yes, you can install Radrails directly to Eclipse (I use Eclipse Ganymade aka 3.4.2) but you ended up with the obsolete 0.72 version :-(

To install the latest 1.30 developed by Aptana and known as Aptana radrails, I was forced to install Aptana Studio and then Install Aptana Radrails

Still, the effort was worth it as the loading time for Eclipse Ganymade SDK version + Aptana Radrails loads much faster and runs faster than Aptana 1.51 Studio + Aptana Radrails.

BTW, take a look at my actual experience in installing Aptana Radrails into Eclipse Galileo aka 3.50

Advanced Rails : How do you create a New Database from schema.db ?

2009-08-19T15:03:00.006+08:00

1. Select your Project

2. Edit config\database.yml
development:
database: SourceDatabaseName

3. Delete schema.db

4. Right-click and select Rake\db\schema\load which basically the same as typing into the Rails Shell

5. Edit config\database.yml
development:
database: ProjectDatabaseName

Nb. Assume that you had already create an empty database for your project

6. rake db:schema:load

That's it, when you check your project database, it is already populated with the Source Schema.

Rails IDE: Programming a Rails Project Using Aptana Radrails

2009-08-18T18:14:00.013+08:00

Here are the steps that I took when programming a RoR project using Aptana Rails 1.5 on Ubuntu 9.04

1. Use MySQL Administrator to create a new database crm2009
2. Use Aptana Radrails(defaulted to Radrails perspective) to create new project via
a) File
b) New
c) Rails Project
and the standard Rail Page was launched apparently without any error

d) Checked Console and found the folowing error message
/!\ FAILSAFE /!\ Tue Aug 18 18:03:01 +0800 2009
Status: 500 Internal Server Error
Access denied for user 'root'@'localhost' (using password: NO)

3. Edited config\database.yml to put in mysql password and the problem went away

Installing Rails Plugin

The problem with Aptana Radrails is that being Eclippse 3.2-based, it does not support installing from the github although using the Rails Plugin Tab works with svn. Worst still, using console script/plugin install also does not work :-(

So what's the workaround ?

Opening a Terminal Window, i was force to type
git clone to download to
crm2009\vendor\plugins

In this manner, I installed restul_authentication,role_requirement,acts_as_audited,active_scaffold etc

Then, I selected vendor\plugins and right-clicked to Refresh and the desired plugins are now in the Ruby Explorer

Installing restful_authentication
a) Select Generate Tab
b) Select authenticated
c)Type user session in parameters
d) Click OK

In the Console, we can see this

script/generate authenticated user sessions
Ready to generate.
----------------------------------------------------------------------
Once finished, don't forget to:

- Add routes to these resources. In config/routes.rb, insert routes like:
map.signup '/signup', :controller => 'users', :action => 'new'
map.login '/login', :controller => 'sessions', :action => 'new'
map.logout '/logout', :controller => 'sessions', :action => 'destroy'

----------------------------------------------------------------------

We've create a new site key in config/initializers/site_keys.rb. If you have existing
user accounts their passwords will no longer work (see README). As always,
keep this file safe but don't post it in public.

----------------------------------------------------------------------
exists app/models/
exists app/controllers/
exists app/controllers/
exists app/helpers/
create app/views/sessions
exists app/controllers/
exists app/helpers/
create app/views/users
exists config/initializers
exists test/functional/
exists test/functional/
exists test/unit/
exists test/fixtures/
create app/models/user.rb
create app/controllers/sessions_controller.rb
create app/controllers/users_controller.rb
create lib/authenticated_system.rb
create lib/authenticated_test_helper.rb
create config/initializers/site_keys.rb
create test/functional/sessions_controller_test.rb
create test/functional/users_controller_test.rb
create test/unit/user_test.rb
create test/fixtures/users.yml
create app/helpers/sessions_helper.rb
create app/helpers/users_helper.rb
create app/views/sessions/new.html.erb
create app/views/users/new.html.erb
create app/views/users/_user_bar.html.erb
create db/migrate
create db/migrate/20090818114130_create_users.rb
route map.resource :session
route map.resources :users
route map.signup '/signup', :controller => 'users', :action => 'new'
route map.register '/register', :controller => 'users', :action => 'create'
route map.login '/login', :controller => 'sessions', :action => 'new'
route map.logout '/logout', :controller => 'sessions', :action => 'destroy'
>

Then, select db/migrate/yymmddhhmmss_create_users.rb
Right-click, select Rake/db/migrate and hit enter an in the Rails Console

rake db:migrate
== CreateUsers: migrating ====================================================
-- create_table("users", {:force=>true})
-> 0.0108s
-- add_index(:users, :login, {:unique=>true})
-> 0.0122s
== CreateUsers: migrated (0.0246s) ===========================================

>

script/generate mailer user
exists app/models/
create app/views/user
exists test/unit/
create test/fixtures/user
overwrite app/models/user.rb? (enter "h" for help) [Ynaqdh] Y
force app/models/user.rb
overwrite test/unit/user_test.rb? (enter "h" for help) [Ynaqdh] Y
force test/unit/user_test.rb

Installing role_requirement

script/generate roles Role User
Generating Role against User
Added the following to the top of app/models/user.rb:

# ---------------------------------------
# The following code has been generated by role_requirement.
# You may wish to modify it to suit your need
has_and_belongs_to_many :roles

# has_role? simply needs to return true or false whether a user has a role or not.
# It may be a good idea to have "admin" roles return true always
def has_role?(role_in_question)
@_list ||= self.roles.collect(&:name)
return true if @_list.include?("admin")
(@_list.include?(role_in_question.to_s) )
end
# ---------------------------------------

Added ApplicationController include to /home/chee/Aptana Studio Workspace/crm2009/app/controllers/application_controller.rb
Added RoleRequirement include to /home/chee/Aptana Studio Workspace/crm2009/app/controllers/application_controller.rb
create test/fixtures/roles.yml
create app/models/role.rb
create lib/role_requirement_system.rb
create lib/role_requirement_test_helper.rb
create lib/hijacker.rb
exists db/migrate
create db/migrate/20090818131928_create_roles.rb
>

Then, select db/migrate/yymmddhhmmss_create_roles.rb
Right-click, select Rake/db/migrate and hit enter an in the Rails Console

rake db:migrate
== CreateRoles: migrating ====================================================
-- create_table("roles")
-> 0.0652s
-- create_table("roles_users", {:id=>false})
-> 0.0066s
-- add_index("roles_users", "role_id")
-> 0.0123s
-- add_index("roles_users", "user_id")
-> 0.0486s
== CreateRoles: migrated (0.1342s) ===========================================

>

More to come...

Announcements : Latest Rails version 2.3.3 Released on 20th July 2009

2009-08-17T18:25:00.010+08:00

Rails 2.3.3: Touching, faster JSON, bug fixes

Posted by David July 20, 2009 @ 05:28 PM

We’ve released Ruby on Rails version 2.3.3. This release fixes a lot of bugs and introduces a handful of new features.

Active Record

touch is a convenient method to update a record’s timestamp and nothing else. This is extracted from apps whose models “touch” others when they change, such as a comment updating the parent.replies_changed_at timestamp after save and destroy. Timestamping an entire has_many association makes it easy to build a key for fragment caching that covers changes to the parent object and any of its children. This pattern is wrapped up as belongs_to :parent, :touch => :replies_changed_at. When the child changes, parent.replies_changed_at is touched. :touch => true is defaults to :touch => :updated_at.
:primary_key option for belongs_to for broader support of legacy schemas and those using a separate UUID primary key: belongs_to :employee, :primary_key => 'SSN', :foreign_key => 'EMPID' changeset

JSON

decoding backends for the json and yajl libraries. Both are significantly faster than the default YAML backend. To get started, install the json gem and set ActiveSupport::JSON.backend = 'JSONGem'.
leaner user-facing encoding API. Since a JSON libraries implement to_json with varying compatibility, safely overriding it is difficult. Most custom to_json looks like
```
def to_json(*encoder_specific_args)
{ :some => "json representation" }.to_json(*encoder_specific_args)
end
```
so we DRYed the user-facing API down to a more natural
```
def as_json(options = {})
{ :some => "json representation" }
end
```
without the ugly internal state exposed by overloading to_json as both public-facing and internal builder API. Rails 3 splits the API explicitly, so prepare now by switching from to_json to as_json.

Other Features

Add :concat option to asset tag helpers to force concatenation. changeset
Restore backwards compatibility for AR::Base#to_xml. changeset
Move from BlueCloth to Markdown for the markdown helper. Users using BlueCloth to provide their markdown functionality should upgrade to version 1.0.1 or 2.0.5 in order to restore compatibility.

Notable Bug Fixes

Fix errors caused by class-reloading with streaming responses in development mode.
Several fixes to the gem bundling, unpacking and installing system.
Make text_area_tag escape contents by default.
Make filter_parameters work correctly with array parameters.
Thread-safety fixes for postgresql string quoting.
Performance fixes for large response bodies.

Ubuntu 9.04 : How to Clone a Remote git Repository ?

2009-08-17T13:42:00.004+08:00

What I did was :-

1. Installed git in Ubuntu 8.04
2. Launch a Terminal Window
3. cd to MyRailsProject\vendor\plugins
4. clone git http://github.com/activescaffld/active_scaffold.git

Rails IDE : How to Install a Plugin in Aptana RadRails Professional ?

2009-08-16T16:22:00.008+08:00

My last project using RoR was completed in Nov 2007 on a Windows 2003 Server and it has been functioning perfectly 24x7x365 till todate

Having installed Ubuntu 9.04 on a dated IBM R40e (1G RAM & 75G HDD), I had earlier
a) Installed Ruby on Rails
b) Installed Aptana Studio 1.5 (based on Eclipse 3.2) and found that it needed Sun JRE
c) Installed Sun JRE via Ubuntu's Terminal
d) Installed the RADRails Plugin into Aptana Studio 1.5
e) I then defaulted Aptana Studio to the RadRails Perspective

Since ActiveScaffold was intensively used, I naturally downloaded it and was at a loss as how to install it :-( Then, I remembered that there was a Plugins Tab which should be visible but it wasn;t there :-(

With a bit of exploring Aptana, I click Window/Show View and clicked Rails Plugin and bingo, the Rails Plugin Tab became visible. It was a breeze after that :-(

Ubuntu 9.04 : How to Install Ruby on Rails 2.3.3 [15th August 2009]

2009-08-15T23:22:00.011+08:00

CCH : These are the steps that I took to install Ruby on Rails to an IBM Thinkpad with 1G RAM and a 75G Hard Disk and installed with Ubuntu 9.04.

Ruby installation

Firstly, I clicked Applications/Accessories/Terminal to launch the Terminal and typed the following command to update the repositories.

sudo apt-get update

next, to upgrade the system :-

sudo apt-get dist-upgrade

The installation took afew minutes and also required approximately 100 MB disk space.
On succesful updating, I started to install Rails.
sudo apt-get install ruby ri rdoc irb libopenssl-ruby ruby-dev

Note : Rails prerequisites include :-
ruby = An interpreter of object-oriented scripting language Ruby
ri = Ruby Interactive reference
rdoc = Generate documentation from ruby source files
irb = Interactive Ruby

Ruby Gem installation

Next, I started to install the Ruby gem package manager by firstly downloading ad the latest Ruby gems .35 via the following link.
http://rubyforge.org/projects/rubygems/

Download and extract the files.

tar xvzf rubygems-1.3.5.tgz
cd rubygems-1.3.5
sudo ruby setup.rb

I then deleted the .tgz file and rubygems directory.

cd ..
rm -r rubygems-1.3.5 rubygems-1.3.5.tgz

Next, I set out to create a set of simlinks. Otherwise it will be a tedious task to type commands with the version (1.8). For an example if we need to call the gem command we’ve to type gem1.8.

sudo ln -s /usr/bin/gem1.8 /usr/local/bin/gem
sudo ln -s /usr/bin/ruby1.8 /usr/local/bin/ruby
sudo ln -s /usr/bin/rdoc1.8 /usr/local/bin/rdoc
sudo ln -s /usr/bin/ri1.8 /usr/local/bin/ri
sudo ln -s /usr/bin/irb1.8 /usr/local/bin/irb

Rails Installation

I then installed Rails using gem.

sudo gem install rails

Server Installation

FYI, Rails by default comes with the WEBrick server. But like most Rails developers, I prefer the Mongrel server and typed the following command to install Mongrel server as well as passenger 2.2.4 and capistrano 2.5.8 for deployemnt purposes

sudo gem install mongrel passenger capistrano

TIP : If you got any error while installing the Mongrel server, install the ruby-dev / ruby1.8-dev and try again.

sudo apt-get install ruby-dev

Database Installation
Rails 2.3 shipped with SQLite3 as it’s default database instead of MySQL. You can install SQLite3 libraries by following commands.

sudo apt-get install sqlite3 swig libsqlite3-ruby libsqlite3-dev
sudo gem install sqlite3-ruby

Since I prefer MySQL,

sudo apt-get install mysql-client libmysqlclient15-dev
sudo gem install mysql

Create Ruby on Rails App

With no error mesages, I proceeded to create a new Ruby on Rail application by following command :-

rails test_app

As I needed MySQL support, I typed :

rails test-app -d mysql

Run the app

cd test_app
script/server

I then point FireFox to http://localhost:3000
and bingo I succeeded in launching my first RoR apps on Ubuntu :-)

Ubuntu 9.04 : How to use the Terminal ?

2009-08-15T17:45:00.005+08:00

Finally, after my last foray (in 2007) into developing RoR applications in Windows, I finally decided to do so in Linux.

Would you believe it, it took a retiree who loves to try out new operating systems to convince me to try out Ubuntu 9.04 ? He actually prefers Mandriva Spring 2009 :-)

So using my usual modus operandi, I googled for 'How to install ruby and ruby on rails on ubuntu 9.04" and got http://mohamedaslam.com/install-ruby-on-rails-on-ubuntu-904-jaunty-jacklope/

Let's see what are the steps

Ruby installation

First we need to update the repositories.

sudo apt-get update

Er... what's sudo and more importantly where do I type it ?

Did a further search and came across something called the Terminal and landed on https://help.ubuntu.com/community/UsingTheTerminal

which says :-

"Under Linux there are GUIs (graphical user interfaces), where you can point and click and drag, and hopefully get work done without first reading lots of documentation. The traditional Unix environment is a CLI (command line interface), where you type commands to tell the computer what to do. That is faster and more powerful, but requires finding out what the commands are."
-- from man intro(1)

For some tasks, especially things like system configuration, it makes sense to use the terminal, and you'll probably have seen instructions on help pages or forums similar to:

sudo gobbledegook blah_blah -w -t -f aWkward/ComBinationOf/mixedCase/underscores_strokes/and.dots

It is often assumed that you know how to use the terminal - and anyone can manage typing and backspacing. But there are some crafty shortcuts which can make your life a lot easier:

How to move around in a terminal window and edit the text that you type there.
Some Linux commands for basic tasks.
Different ways to open a terminal, how to work with multiple terminals, etc.

Using this page

This page will help familiarize you with basic GNU/Linux shell commands.
It is not intended to be a complete guide to the command line, just an introduction to complement Ubuntu's graphical tools.
All command names will be in bold.
Commands needing to be typed will be in "bold with quotes".
All of the commands on this page are to be issued from a command prompt in a terminal.
Note that the terminal is case sensitive. User, user, and USER are all different to Linux.

Starting a Terminal

In Gnome (Ubuntu)

The terminal can be found at Applications menu -> Accessories -> Terminal.

In Xfce (Xubuntu)

The terminal can be found at Applications menu -> System -> Terminal.

In KDE (Kubuntu)

The terminal can be found at KMenu -> System -> Terminal Program (Konsole).

Commands

sudo: Executing Commands with Elevated Privileges

Most of the following commands will need to be prefaced with the sudo command if you will be working with directories or files not owned by your account. This is a special command which temporarily gives you access to change computer settings. The terminal will ask you for your password. Please see RootSudo for information on using sudo.

File & Directory Commands

pwd: The pwd command will allow you to know in which directory you're located (pwd stands for "print working directory"). Example: "pwd" in the Desktop directory will show "~/Desktop". Note that the Gnome Terminal also displays this information in the title bar of its window.
ls: The ls command will show you the files in your current directory. Used with certain options, you can see sizes of files, when files were made, and permissions of files. Example: "ls ~" will show you the files that are in your home directory.
cd: The cd command will allow you to change directories. When you open a terminal you will be in your home directory. To move around the file system you will use cd. Examples:
- To navigate into the root directory, use "cd /"
- To navigate to your home directory, use "cd" or "cd ~"
- To navigate up one directory level, use "cd .."
- To navigate to the previous directory (or back), use "cd -"
- To navigate through multiple levels of directory at once, specify the full directory path that you want to go to. For example, use, "cd /var/www" to go directly to the /www subdirectory of /var/. As another example, "cd ~/Desktop" will move you to the Desktop subdirectory inside your home directory.
cp: The cp command will make a copy of a file for you. Example: "cp file foo" will make a exact copy of "file" and name it "foo", but the file "file" will still be there. If you are copying a directory, you must use "cp -r directory foo" (copy recursively).
mv: The mv command will move a file to a different location or will rename a file. Examples are as follows: "mv file foo" will rename the file "file" to "foo". "mv foo ~/Desktop" will move the file "foo" to your Desktop directory but will not rename it. You must specify a new file name to rename a file.
- To save on typing, you can substitute '~' in place of the home directory.
- Note that if you are using mv with sudo you can use the ~ shortcut, because the terminal expands the ~ to your home directory. However, when you open a root shell with sudo -i or sudo -s, ~ will refer to the root account's home directory, not your own.
rm: Use this command to remove or delete a file in your directory.
rmdir: The rmdir command will delete an empty directory. To delete a directory and all of its contents recursively, use rm -r instead.
mkdir: The mkdir command will allow you to create directories. Example: "mkdir music" will create a directory called "music".
man: The man command is used to show you the manual of other commands. Try "man man" to get the man page for man itself. See the "Man & Getting Help" section down the page for more information.

System Information Commands

df: The df command displays filesystem disk space usage for all mounted partitions. "df -h" is probably the most useful - it uses megabytes (M) and gigabytes (G) instead of blocks to report. (-h means "human-readable")
du: The du command displays the disk usage for a directory. It can either display the space used for all subdirectories or the total for the directory you run it on. Example:

user@users-desktop:~$ du /media/floppy
1032    /media/floppy/files
1036    /media/floppy/
user@users-desktop:~$ du -sh /media/floppy
1.1M    /media/floppy/

-s means "Summary" and -h means "Human Readable"

free: The free command displays the amount of free and used memory in the system. "free -m" will give the information using megabytes, which is probably most useful for current computers.
top: The top command displays information on your Linux system, running processes and system resources, including CPU, RAM & swap usage and total number of tasks being run. To exit top, press "q".
uname -a: The uname command with the -a option prints all system information, including machine name, kernel name & version, and a few other details. Most useful for checking which kernel you're using.
lsb_release -a: The lsb_release command with the -a option prints version information for the Linux release you're running, for example:

user@computer:~$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 6.06 LTS
Release:        6.06
Codename:       dapper

ifconfig reports on your system's network interfaces.

Adding A New User

"adduser newuser" command will create a new general user called "newuser" on your system, and to assign a password for the newuser account use "passwd newuser".

Options

The default behaviour for a command may usually be modified by adding a --option to the command. The ls command for example has an -s option so that "ls -s" will include file sizes in the listing. There is also a -h option to get those sizes in a "human readable" format.

Options can be grouped in clusters so "ls -sh" is exactly the same command as "ls -s -h". Most options have a long version, prefixed with two dashes instead of one, so even "ls --size --human-readable" is the same command.

"Man" and getting help

man command, info command and command --help are the most important tools at the command line.

Nearly every command and application in Linux will have a man (manual) file, so finding them is as simple as typing "man "command"" to bring up a longer manual entry for the specified command. For example, "man mv" will bring up the mv (Move) manual.

Move up and down the man file with the arrow keys, and quit back to the command prompt with "q".

"man man" will bring up the manual entry for the man command, which is a good place to start!

"man intro" is especially useful - it displays the "Introduction to user commands" which is a well-written, fairly brief introduction to the Linux command line.

There are also info pages, which are generally more in-depth than man pages. Try "info info" for the introduction to info pages.

Some software developers prefer info to man (for instance, GNU developers), so if you find a very widely used command or app that doesn't have a man page, it's worth checking for an info page.

Virtually all commands understand the -h (or --help) option which will produce a short usage description of the command and it's options, then exit back to the command prompt. Try "man -h" or "man --help" to see this in action.

Caveat: It's possible (but rare) that a program doesn't understand the -h option to mean help. For this reason, check for a man or info page first, and try the long option --help before -h.

Searching for man files

If you aren't sure which command or application you need to use, you can try searching the man files.

man -k foo will search the man files for foo. Try "man -k nautilus" to see how this works.
- Note that this is the same as doing apropos command.
man -f foo searches only the titles of your system's man files. Try "man -f gnome", for example.
- Note that this is the same as doing whatis command.

Other Useful Things

Prettier Manual Pages

Users who have Konqueror installed will be pleased to find they can read and search man pages in a web browser context, prettified with their chosen desktop fonts and a little colour, by visiting man:/command in Konqueror's address bar. Some people might find this lightens the load if there's lots of documentation to read/search.

Pasting in commands

Often, you will be referred to instructions that require commands to be pasted into the terminal. You might be wondering why the text you've copied from a web page using ctrl+C won't paste in with ctrl+V. Surely you don't have to type in all those nasty commands and filenames? Relax. Middle Button Click on your mouse (both buttons simultaneously on a two-button mouse) or Right Click and select Paste from the menu.

Save on typing

Up Arrow or ctrl+p	Scrolls through the commands you've entered previously.
Down Arrow or ctrl+n	Takes you back to a more recent command.
Enter	When you have the command you want.
tab	A very useful feature. It autocompletes any commands or filenames, if there's only one option, or else gives you a list of options.
ctrl+r	Searches for commands you've already typed. When you have entered a very long, complex command and need to repeat it, using this key combination and then typing a portion of the command will search through your command history. When you find it, simply press Enter.
History	The history command shows a very long list of commands that you have typed. Each command is displayed next to a number. You can type !x to execute a previously typed command from the list (replace the X with a number). If you history output is too long, then use history \| less for a scrollable list.

Change the text

The mouse won't work. Use the Left/Right arrow keys to move around the line.

When the cursor is where you want it in the line, typing inserts text - ie it doesn't overtype what's already there.

ctrl+a or Home	Moves the cursor to the start of a line.
ctrl+e or End	Moves the cursor to the end of a line.
ctrl+b	Moves to the beginning of the previous or current word.
ctrl+k	Deletes from the current cursor position to the end of the line.
ctrl+u	Deletes the whole of the current line.
ctrl+w	Deletes the word before the cursor.

More ways to run a terminal

You can also get it with a function key

You can run more than one - in tabs or separate windows

More Information

AptGetHowto - using apt-get to install packages from the command line.
Commandline Repository Editing - adding the Universe/Multiverse repositories through the command line.
grep Howto - grep is a powerful command line search tool.
find Howto - locate files on the command line.
CommandlineHowto - longer and more complete than this basic guide, but still unfinished.
HowToReadline - information on some more advanced customization for the command line.

For more detailed tutorials on the Linux command line, please see:

http://linuxcommand.org/ - basic BASH tutorials, including BASH scripting
http://linuxsurvival.com/index.php - Java-based tutorials
http://rute.2038bug.com/index.html.gz - a massive online book about system administration, almost all from the command line.
http://www.ss64.com/bash/ - a good list a commands.

Rails Documentation : Ruby on Rails guides

2009-07-30T19:38:00.002+08:00

CCH : From the Net

These guides are designed to make you immediately productive with Rails, and to help you understand how all of the pieces fit together. There are two different versions of the Guides site, and you should be sure to use the one that applies to your situation:

Current Release version – based on Rails 2.3
Edge version – based on the current Rails master branch

Announcements : Rails 2.3: Templates, Engines, Rack, Metal, much more!

2009-04-24T19:08:00.007+08:00

Posted by David March 16, 2009 @ 02:39 PM

Rails 2.3 is finally done and out the door. This is one of the most substantial upgrades to Rails in a very long time. A brief rundown of the top hitters:

Templates: Allows your new skeleton 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.

And that’s just the tip of the iceberg. We’ve put together a complete guide for the Rails 2.3 release notes with much more information. Be sure to checkout the section on what was deprecated when you’re ready to upgrade your application.

You install 2.3 with (the final version is marked 2.3.2):

gem install rails

If you’re running on Passenger, be sure to upgrade to 2.1.2 as well. Rails 2.3 doesn’t run on older versions of Passenger!

We hope you’ll love it.

Announcements : Radrails 1.1.2 Released

2009-02-17T08:16:00.002+08:00

by cwilliams » Wed Feb 04, 2009 9:45 pm

RadRails 1.1.2 has been released to stable. Users who are on 1.1.1 are recommended to upgrade. Aptana should prompt you to automatically upgrade if you're on 1.1.1. To manually install (for users of older releases, or those experiencing problems) the update site is: http://update.aptana.com/update/rails/3.2/

The changelog for this release is at: http://support.aptana.com/asap/browse/ROR/fixforversion/10153

This is a bugfix only release.

Announcements : Rails 2.3.0 RC1 - Relesed on 1 February 2009

2009-02-16T21:43:00.005+08:00

Rails 2.3.0 RC1: Templates, Engines, Rack, Metal, much more!

Posted by David February 01, 2009 @ 11:40 PM

Rails 2.3 is almost ready for release, but this package is so stock full of amazing new stuff that we’re making dutifully sure that everything works right before we call it official.

So please help us do thorough testing of this release candidate. Lots of the underpinnings changed. Especially the move to Rack. So we need solid testing and will probably have a slightly longer than average release candidate phase to account for that.

But boy will it be worth it. This is one of the most substantial upgrades to Rails in a very long time. A brief rundown of the top hitters:

Templates: Allows your new skeleton 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.

And that’s just the tip of the iceberg. We’ve put together a complete guide for the Rails 2.3 release notes with much more information.

You can install the release candidate with:

gem install rails --source http://gems.rubyonrails.org

Enjoy, report the bugs, and let’s get Rails 2.3 final out the door soon.

Announcements : Rails 2.2 is Released on 21 December 2008

2009-02-16T21:37:00.004+08:00

Rails 2.2: i18n, HTTP validators, thread safety, JRuby/1.9 compatibility, docs

Posted by David November 21, 2008 @ 05:22 PM

Rails 2.2 is finally done after we cleared the last issues from the release candidate program. This release contains an long list of fixes, improvements, and additions that’ll make everything Rails smoother and better, but we also have a number of star player features to parade this time.

Internationalization by default
The most important is that Rails now includes a full-on internationalization framework and that it’s pre-wired from start. The work of the i18n group has been very impressive and it’s great to see that Rails finally ships with a solution in the box that’s both simple and extensible. Great job, guys!

Stronger etag and last-modified support
We’ve also added much better support for HTTP validators in the form of etag and last-modified. Making it so much easier to skip expensive procesesing if the client already has the latest stuff. This also makes it even easier to use Rails with gateway proxies.

Thread safety and a connection pool
Josh Peek has added thread safety to Rails and Nick Sieger from JRuby worked on getting Active Record a proper connection pool. So now all elements of Rails are thread safe, which is a big boon for the JRuby guys in particular. For C Ruby, we still need a bunch of dependent libraries to go non-blocking before it’ll make much of a difference, but work on that is forth coming.

Ruby 1.9 and JRuby compatibility
Jeremy Kemper has been rocking on both Ruby 1.9 and JRuby compatibility. Rails 2.2 is fully compatible with both, but again, there might be supporting libraries and gems that are not. Again, lots of work is going into making everything else fully compatible as well.

Better API docs, great guides
Finally, the last big push has been with the documentation of Rails. Pratik’s docrails project has made immense progress. Not only are the API docs much improved, but we also have a wholenew guides section generated from documentation that now lives with the source. A true community project with lots of contributors. I’m sure both those new and old to Rails will greatly appreciate the strong focus on documentation.

To read about all these features and more in details, checkoutthe Rails 2.2 release notes—another one of those guides from the docrails project.

How to install
As always, you can install Rails 2.2 through RubyGems. We now require RubyGems 1.3.1, so be sure to update that first: gem update --system

Then you can install Rails: gem install rails

If you’re updating an existing application, you can run rake rails:update to get the latest JavaScript files and scripts.

From all of us to all of you, we hope you enjoy this release. It’s a true pleasure to see Rails make such big steps forward once again. Dig in, have fun, and we’ll be back with Rails 2.3 with even more before you know it.

Announcements : Instant Rails 2.0 Released on 28th December 2007

2007-12-29T12:45:00.003+08:00

Rob Bazinet has announced on 28/12/07 the release of Instant Rails 2.0. This is his first release after taking over the project for Curt Hibbs.

This release is part of bringing the environment up-to-date, no earth shattering changes but the following is updated:
- Ruby 1.8.6 Patch Level 111 with tons of bug fixes and new updated gems
- Ruby on Rails 2.0.2
- RubyGems 1.0.1
- Rake 0.8.0
- Mongrel 1.1.2
- SQLite3

Instant Rails 2.0 can be downloaded from RubyForge now<http://rubyforge.org/frs/?group_id=904>

For the Release Notes, go to <http://instantrails.rubyforge.org/wiki/wiki.pl?Release_Notes_For_Instant_Rails_2.0>to see all the updates.

Questions should be submitted to the Instant Rails list <http://rubyforge.org/mail/?group_id=904>

-Rob Bazinet http://www.accidentaltechnologist.com/

Announcements : Rails 2.0.2 Released on 17 December 2007

2007-12-19T13:39:00.003+08:00

Quoted Verbatim from DHH

Now that we have the big Rails 2.0 release out the door, it’s a lot easier to push out smaller updates more frequently. So that’s what we’re going to do. Rails 2.0.2 contains a bunch of smaller fixes to various bugs, no show-stopping action, just further polish. But it also contains a few new defaults.

SQLite3 is the new default database

Most importantly is SQLite3 as the new database we’ll configure for by default when you run the rails generation command without any specification. This change comes as SQLite3 is simply an easier out of the box experience than MySQL. There’s no fussing with GRANTs and creates, the database is just there. This is especially so under OS X 10.5 Leopard, which ships with SQLite3 and the driver gems preinstalled as part of the development kit.

If you want to preconfigure your database for MySQL (or any of the other adapters), you simply do “rails -d mysql myapp” and everything is the same as before. But if you’re just playing with a new application or building a smallish internal tool, then I strongly recommend having a look at SQLite3. Thanks to the agnostic db/schema.rb, it’s as easy as changing your config/database.yml to switch from SQLite3 to MySQL (or another database) as soon as your load warrants it.

Don’t check for template changes in production mode

New applications will be generated with the following option in their config/environments/production.rb:

config.action_view.cache_template_loading = trueThis will stop Rails from constantly doing STAT calls to the file system to check if the file has changed. This can make for a lot of I/O activity, especially if you have lots of partials. If you have very fast disks, this may not matter, but if you’re running off slower disks it can make quite a big difference.

The drawback is that you can no longer just svnup a single template file and see it changed immediately. You’ll have to restart the application servers to make that happen.

Regardless, we feel that this is the better default in a partial-heavy world, but you’re of course always free to change it.

Rails 2.0.2 is a drop-in replacement for Rails 2.0

To upgrade, just do “gem install rails” (if the gems are still not propagated, use—source http://gems.rubyonrails.org) or use the new rel_2-0-2 tag.

The rest of the changes are as follows:

Action Pack

Added delete_via_redirect and put_via_redirect to integration testing #10497 [philodespotos]

Allow headers[‘Accept’] to be set by hand when calling xml_http_request #10461 [BMorearty]

Added OPTIONS to list of default accepted HTTP methods #10449 [holoway]

Added option to pass proc to ActionController::Base.asset_host for maximum configurability #10521 [chuyeow]. Example:
ActionController::Base.asset_host = Proc.new { source if source.starts_with?(’/images’) “http://images.example.com” else “http://assets.example.com” end }

Fixed that ActionView#file_exists? would be incorrect if @first_render is set #10569 [dbussink]

Added that Array#to_param calls to_param on all it’s elements #10473 [brandon]

Ensure asset cache directories are automatically created. #10337 [Josh Peek, Cheah Chu Yeow]

render :xml and :json preserve custom content types. #10388 [jmettraux, Cheah Chu Yeow]

Refactor Action View template handlers. #10437, #10455 [Josh Peek]

Fix DoubleRenderError message and leave out mention of returning false from filters. Closes #10380 [Frederick Cheung]

Clean up some cruft around ActionController::Base#head. Closes #10417 [ssoroka]

Active Record

Ensure optimistic locking handles nil #lock_version values properly. Closes #10510 [rick]

Make the Fixtures Test::Unit enhancements more supporting for double-loaded test cases. Closes #10379 [brynary]

Fix that validates_acceptance_of still works for non-existent tables (useful for bootstrapping new databases). Closes #10474 [hasmanyjosh]

Ensure that the :uniq option for has_many :through associations retains the order. #10463 [remvee]

Base.exists? doesn’t rescue exceptions to avoid hiding SQL errors. #10458 [Michael Klishin]

Documentation: Active Record exceptions, destroy_all and delete_all. #10444, #10447 [Michael Klishin]

Active Resource

Added more specific exceptions for 400, 401, and 403 (all descending from ClientError so existing rescues will work) #10326 [trek]

Correct empty response handling. #10445 [seangeo]

Active Support

Ruby 1.9 compatibility. #1689, #10466, #10468 [Cheah Chu Yeow, Pratik Naik, Jeremy Kemper]

TimeZone#to_s uses UTC rather than GMT. #1689 [Cheah Chu Yeow]

Refactor of Hash#symbolize_keys! to use Hash#replace. Closes #10420 [ReinH]

Fix HashWithIndifferentAccess#to_options! so it doesn’t clear the options hash. Closes #10419 [ReinH]

Rails

Changed the default database from mysql to sqlite3, so now running “rails myapp” will have a config/database.yml that’s setup for SQLite3 (which in OS X Leopard is installed by default, so is the gem, so everything Just Works with no database configuration at all). To get a Rails application preconfigured for MySQL, just run “rails -d mysql myapp” [DHH]

Turned on ActionView::Base.cache_template_loading by default in config/environments/production.rb to prevent file system stat calls for every template loading to see if it changed (this means that you have to restart the application to see template changes in production mode) [DHH]

Introduce `rake secret` to output a crytographically secure secret key for use with cookie sessions #10363 [revans]

Fixed that local database creation should consider 127.0.0.1 local #9026 [parcelbrat]

Fixed that functional tests generated for scaffolds should use fixture calls instead of hard-coded IDs #10435 [boone]

Added db:migrate:redo and db:migrate:reset for rerunning existing migrations #10431, #10432 [matt]

RAILS_GEM_VERSION may be double-quoted also. #10443 [James Cox]

Update rails:freeze:gems to work with RubyGems 0.9.5. [Jeremy Kemper]

Announcements : Rails 2.0.1 has been released on 7th December 2007

2007-12-09T17:02:00.003+08:00

As quoted by DHH verbatim, Rails 2.0 is finally finished after about a year in the making. This is a fantastic release that’s absolutely stuffed with great new features, loads of fixes, and an incredible amount of polish. We’ve even taken a fair bit of cruft out to make the whole package more coherent and lean.

What’s new ?

Action Pack: Resources
This is where the bulk of the action for 2.0 has gone. We’ve got a slew of improvements to the RESTful lifestyle. First, we’ve dropped the semicolon for custom methods instead of the regular slash. So /people/1;edit is now /people/1/edit.

We’ve also added the namespace feature to routing resources that makes it really easy to confine things like admin interfaces:map.namespace(:admin) do admin
admin.resources :products,
:collection => { :inventory => :get },
:member => { :duplicate => :post },
:has_many => [ :tags, :images, :variants ]
end

Which will give you named routes like inventory_admin_products_url and admin_product_tags_url.

To keep track of this named routes proliferation, we’ve added the “rake routes” task, which will list all the named routes created by routes.rb.

We’ve also instigated a new convention that all resource-based controllers will be plural by default. This allows a single resource to be mapped in multiple contexts and still refer to the same controller. Example:
# /avatars/45 => AvatarsController#show
map.resources :avatars
# /people/5/avatar => AvatarsController#show
map.resources :people, :has_one => :avatar

Action Pack: Multiview
Alongside the improvements for resources come improvements for multiview.

We already have #respond_to, but we’ve taken it a step further and made it dig into the templates. We’ve separated the format of the template from its rendering engine.

So show.rhtml now becomes show.html.erb, which is the template that’ll be rendered by default for a show action that has declared format.html in its respond_to. And you can now have something like show.csv.erb, which targets text/csv, but also uses the default ERB renderer.

So the new format for templates is action.format.renderer. A few examples:
show.erb: same show template for all formats
index.atom.builder: uses the Builder format, previously known as rxml, to render an index action for the application/atom+xml mime type
edit.iphone.haml: uses the custom HAML template engine (not included by default) to render an edit action for the custom Mime::IPHONE format

Speaking of the iPhone, we’ve made it easier to declare “fake” types that are only used for internal routing. Like when you want a special HTML interface just for an iPhone. All it takes is something like this:
# should go in config/initializers/mime_types.rb
Mime.register_alias "text/html", :iphone
class ApplicationController < format =" :iphone">

Action Pack: Record identification
Piggy-backing off the new drive for resources are a number of simplifications for controller and view methods that deal with URLs.

We’ve added a number of conventions for turning model classes into resource routes on the fly. Examples:
# person is a Person object, which by convention will
# be mapped to person_url for lookup
redirect_to(person)
link_to(person.name, person)
form_for(person)

Action Pack: HTTP Loving
As you might have gathered, Action Pack in Rails 2.0 is all about getting closer with HTTP and all its glory. Resources, multiple representations, but there’s more.

We’ve added a new module to work with HTTP Basic Authentication, which turns out to be a great way to do API authentication over SSL. It’s terribly simple to use. Here’s an example (there are more in ActionController::HttpAuthentication):
class PostsController < password = "dhh" except =""> [ :index ]
def index
render :text => "Everyone can see me!"
end
def edit
render :text => "I'm only accessible if you know the password"
end
private

def authenticate
authenticate_or_request_with_http_basic do user_name, password
user_name == USER_NAME && password == PASSWORD
end
end
end

We’ve also made it much easier to structure your JavaScript and stylesheet files in logical units without getting clobbered by the HTTP overhead of requesting a bazillion files. Using javascript_include_tag(:all, :cache => true) will turn public/javascripts/.js into a single public/javascripts/all.js file in production, while still keeping the files separate in development, so you can work iteratively without clearing the cache.

Along the same lines, we’ve added the option to cheat browsers who don’t feel like pipelining requests on their own. If you set ActionController::Base.asset_host = “assets%d.example.com”, we’ll automatically distribute your asset calls (like image_tag) to asset1 through asset4. That allows the browser to open many more connections at a time and increases the perceived speed of your application.

Action Pack: Security
Making it even easier to create secure applications out of the box is always a pleasure and with Rails 2.0 we’re doing it from a number of fronts. Most importantly, we now ship we a built-in mechanism for dealing with CRSF attacks.

By including a special token in all forms and Ajax requests, you can guard from having requests made from outside of your application. All this is turned on by default in new Rails 2.0 applications and you can very easily turn it on in your existing applications using ActionController::Base.protect_from_forgery (see ActionController::RequestForgeryProtection for more).

We’ve also made it easier to deal with XSS attacks while still allowing users to embed HTML in your pages. The old TextHelper#sanitize method has gone from a black list (very hard to keep secure) approach to a white list approach. If you’re already using sanitize, you’ll automatically be granted better protection. You can tweak the tags that are allowed by default with sanitize as well. See TextHelper#sanitize for details.

Finally, we’ve added support for HTTP only cookies. They are not yet supported by all browsers, but you can use them where they are.

Action Pack: Exception handling
Lots of common exceptions would do better to be rescued at a shared level rather than per action. This has always been possible by overwriting rescue_action_in_public, but then you had to roll out your own case statement and call super. Bah. So now we have a class level macro called rescue_from, which you can use to declaratively point certain exceptions to a given action.

Example:
class PostsController < with =""> :deny_access
protected
def deny_access
...
end
end

Action Pack: Cookie store sessions
The default session store in Rails 2.0 is now a cookie-based one.

That means sessions are no longer stored on the file system or in the database, but kept by the client in a hashed form that can’t be forged. This makes it not only a lot faster than traditional session stores, but also makes it zero maintenance. There’s no cron job needed to clear out the sessions and your server won’t crash because you forgot and suddenly had 500K files in tmp/session.

This setup works great if you follow best practices and keep session usage to a minimum, such as the common case of just storing a user_id and a the flash. If, however, you are planning on storing the nuclear launch codes in the session, the default cookie store is a bad deal. While they can’t be forged (so is_admin = true is fine), their content can be seen. If that’s a problem for your application, you can always just switch back to one of the traditional session stores (but first investigate that requirement as a code smell).

Action Pack: New request profiler
Figuring out where your bottlenecks are with real usage can be tough, but we just made it a whole lot easier with the new request profiler that can follow an entire usage script and report on the aggregate findings. You use it like this:
$ cat login_session.rb
get_with_redirect '/'
say "GET / => #{path}"
post_with_redirect '/sessions', :username => 'john', :password => 'doe'
say "POST /sessions => #{path}"
$ ./script/performance/request -n 10 login_session.rb
And you get a thorough breakdown in HTML and text on where time was spent and you’ll have a good idea on where to look for speeding up the application.

Action Pack: Miscellaneous
Also of note is AtomFeedHelper, which makes it even simpler to create Atom feeds using an enhanced Builder syntax. Simple example:
# index.atom.builder:
atom_feed do feed
feed.title("My great blog!")
feed.updated((@posts.first.created_at))
for post in @posts
feed.entry(post) do entry
entry.title(post.title)
entry.content(post.body, :type => 'html')
entry.author do author
author.name("DHH")
end
end
end
end

We’ve made a number of performance improvements, so asset tag calls are now much cheaper and we’re caching simple named routes, making them much faster too.

Finally, we’ve kicked out in_place_editor and autocomplete_for into plugins that live on the official Rails SVN.

Active Record: Performance
Active Record has seen a gazillion fixes and small tweaks, but it’s somewhat light on big new features.

Something new that we have added, though, is a very simple Query Cache, which will recognize similar SQL calls from within the same request and return the cached result. This is especially nice for N+1 situations that might be hard to handle with :include or other mechanisms. We’ve also drastically improved the performance of fixtures, which makes most test suites based on normal fixture use be 50-100% faster.

Active Record: Sexy migrations
There’s a new alternative format for declaring migrations in a slightly more efficient format.

Before you’d write:
create_table :people do t
t.column, "account_id", :integer
t.column, "first_name", :string, :null => false
t.column, "last_name", :string, :null => false
t.column, "description", :text
t.column, "created_at", :datetime
t.column, "updated_at", :datetime
end

Now you can write:
create_table :people do t
t.integer :account_id
t.string :first_name, :last_name, :null => false
t.text :description
t.timestamps
end

Active Record: Foxy fixtures
The fixtures in Active Record has taken a fair amount of flak lately. One of the key points in that criticism has been the work with declaring dependencies between fixtures. Having to relate fixtures through the ids of their primary keys is no fun. That’s been addressed now and you can write fixtures like this:
# sellers.yml
shopify:
name: Shopify
# products.yml
pimp_cup:
seller: shopify
name: Pimp cup

As you can see, it’s no longer necessary to declare the ids of the fixtures and instead of using seller_id to refer to the relationship, you just use seller and the name of the fixture.

Active Record: XML in, JSON out
Active Record has supported serialization to XML for a while. In 2.0 we’ve added deserialization too, so you can say Person.new.from_xml(“David“) and get what you’d expect. We’ve also added serialization to JSON, which supports the same syntax as XML serialization (including nested associations). Just do person.to_json and you’re ready to roll.

Active Record: Shedding some weight
To make Active Record a little leaner and meaner, we’ve removed the acts_as_XYZ features and put them into individual plugins on the Rails SVN repository. So say you’re using acts_as_list, you just need to do ./script/plugin install acts_as_list and everything will move along like nothing ever happened.

A little more drastic, we’ve also pushed all the commercial database adapters into their own gems. So Rails now only ships with adapters for MySQL, SQLite, and PostgreSQL. These are the databases that we have easy and willing access to test on. But that doesn’t mean the commercial databases are left out in the cold. Rather, they’ve now been set free to have an independent release schedule from the main Rails distribution. And that’s probably a good thing as the commercial databases tend to require a lot more exceptions and hoop jumping on a regular basis to work well.

The commercial database adapters now live in gems that all follow the same naming convention: activerecord-XYZ-adapter. So if you gem install activerecord-oracle-adapter, you’ll instantly have Oracle available as an adapter choice in all the Rails applications on that machine. You won’t have to change a single line in your applications to take use of it.
That also means it’ll be easier for new database adapters to gain traction in the Rails world. As long as you package your adapter according to the published conventions, users just have to install the gem and they’re ready to roll.

Active Record: with_scope with a dash of syntactic vinegar
ActiveRecord::Base.with_scope has gone protected to discourage people from misusing it in controllers (especially in filters). Instead, it’s now encouraged that you only use it within the model itself. That’s what it was designed for and where it logically remains a good fit. But of course, this is all about encouraging and discouraging. If you’ve weighed the pros and the cons and still want to use with_scope outside of the model, you can always call it through .send(:with_scope).

ActionWebService out, ActiveResource in
It’ll probably come as no surprise that Rails has picked a side in the SOAP vs REST debate. Unless you absolutely have to use SOAP for integration purposes, we strongly discourage you from doing so. As a naturally extension of that, we’ve pulled ActionWebService from the default bundle. It’s only a gem install actionwebservice away, but it sends an important message none the less.

At the same time, we’ve pulled the new ActiveResource framework out of beta and into the default bundle. ActiveResource is like ActiveRecord, but for resources. It follows a similar API and is configured to Just Work with Rails applications using the resource-driven approach. For example, a vanilla scaffold will be accessible by ActiveResource.

ActiveSupport
There’s not all that much new in ActiveSupport. We’ve a host of new methods like Array#rand for getting a random element from an array, Hash#except to filter down a hash from undesired keys and lots of extensions for Date. We also made testing a little nicer with assert_difference. Short of that, it’s pretty much just fixes and tweaks.

Action Mailer
This is a very modest update for Action Mailer. Besides a handful of bug fixes, we’ve added the option to register alternative template engines and assert_emails to the testing suite, which works like this:
Assert number of emails delivered within a block: assert_emails 1 do post :signup, :name => ‘Jonathan’ end

Rails: The debugger is back
To tie it all together, we have a stream of improvements for Rails in general. My favorite amongst these is the return of the breakpoint in form of the debugger. It’s a real debugger too, not just an IRB dump. You can step back and forth, list your current position, and much more. It’s all coming from the gracious note of the ruby-debug gem. So you’ll have to install that for the new debugger to work.

To use the debugger, you just install the gem, put “debugger” somewhere in your application, and then start the server with—debugger or -u. When the code executes the debugger command, you’ll have it available straight in the terminal running the server. No need for script/breakpointer or anything else. You can use the debugger in your tests too.

Rails: Clean up your environment
Before Rails 2.0, config/environment.rb files every where would be clogged with all sorts of one-off configuration details.

Now you can gather those elements in self-contained files and put them under config/initializers and they’ll automatically be loaded. New Rails 2.0 applications ship with two examples in form of inflections.rb (for your own pluralization rules) and mime_types.rb (for your own mime types). This should ensure that you need to keep nothing but the default in config/environment.rb.

Rails: Easier plugin order
Now that we’ve yanked out a fair amount of stuff from Rails and into plugins, you might well have other plugins that depend on this functionality. This can require that you load, say, acts_as_list before your own acts_as_extra_cool_list plugin in order for the latter to extend the former.

Before, this required that you named all your plugins in config.plugins. Major hassle when all you wanted to say was “I only care about acts_as_list being loaded before everything else”. Now you can do exactly that with config.plugins = [ :acts_as_list, :all ].
And hundreds upon hundreds of other improvements

What I’ve talked about above is but a tiny sliver of the full 2.0 package. We’ve got literally hundreds of bug fixes, tweaks, and feature enhancements crammed into Rails 2.0. All this coming off the work of tons of eager contributors working tirelessly to improve the framework in small, but important ways.
I encourage you to scourger the CHANGELOGs and learn more about all that changed.

So how do I upgrade?
If you want to move your application to Rails 2.0, you should first move it to Rails 1.2.6. That’ll include deprecation warnings for most everything we yanked out in 2.0. So if your application runs fine on 1.2.6 with no deprecation warnings, there’s a good chance that it’ll run straight up on 2.0. Of course, if you’re using, say, pagination, you’ll need to install the classic_pagination plugin. If you’re using Oracle, you’ll need to install the activerecord-oracle-adapter gem. And so on and so forth for all the extractions.

So how do I install?
To install through gems, do:gem install rails -y
...if you’re having trouble with that (gem not found), just grab gems from our own repository in the meanwhile:gem install rails -y --source http://gems.rubyonrails.org/

To try it from an SVN tag, use (you may need to run this command twice depending on your current Rails version):rake rails:freeze:edge TAG=rel_2-0-1

Note: It’s 2.0.1 because we found a small issue just after we pushed 2.0.0.

Announcements : Rails 1.2.6: Security and Maintenance Release

2007-11-25T17:40:00.003+08:00

Ruby on Rails 1.2.6: Security and Maintenance Release has been released on November 24, 2007 by the rails core team to address a bug in the fix for session fixation attacks (CVE-2007-5380). The CVE Identifier for this new issue is CVE-2007-6077.

You should upgrade to this new release if you do not take specific session-fixation counter measures in your application. 1.2.6 also fixes some regressions when working with has_many associations on unsaved ActiveRecord objects.

As with other 1.2.x releases, this is intended as a drop in upgrade for users of earlier versions in the 1.2 series.

To upgrade, `gem install rails`, set RAILS_GEM_VERSION to ‘1.2.6’ in config/environment.rb, and `rake rails:update:configs`.

Announcements : Aptana Radrails 0.9.1 Final Release

2007-11-18T17:24:00.001+08:00

For Radrails users, there is happy news !

Aptana RadRails 0.9.1 Final Release has been released since 15th November 2007. Users who are still on 0.8.0 are highly recommended to upgrade.

Here's the Trac changelog: http://www.aptana.com/trac/milestone/RadRails%20IDE%200.9.1 And the ASAP one: http://support.aptana.com/issues/browse/ROR/fixforversion/10004

Announcements : Rails 2.0 Release Candidate 1

2007-11-10T18:35:00.003+08:00

Looks as if Rails 2.0 will be released soon if this post by DHH (creator of Rails) today at the Ruby on Rails : Talk Google Group is any indication :-

We're almost there. Really this time.
http://weblog.rubyonrails.org/2007/11/9/rails-2-0-release-candidate-1

BTW, the basic advice is to upgrade to 1.2.5 and get rid of all deprecation warnings.

Advanced Rails : Testing a Ruby on Rails Application [Updated 30th August 2009]

2007-11-03T15:12:00.003+08:00

Thanks to DHH and his team, Rails guides you to create a well-tested application by actively generating default test cases and setting up scripts and tools to run 3 different kinds of tests namely, unit testing, functional testing and integration testing.

For example, when you use script/generate to create your models and controllers, Rails also generates skeletal test files for you to flesh out with tests for your apps.

1) Unit Testing deals with tests on models.
2) Controllers are tested via Functional Testing
3) Integration Testing focuses on the testing of the interation between controllers

Rails has a number of features that make it easy to test your application. In particular, Rails uses a separate runtime database dedicated to testing and can automatically populate the test database with fresh sample data (that you provide) before each test.

This is how you execute the tests :-

a) Test all units and functionals
rake test

b) Run tests for functionals
rake test:functionals

c) Run tests for integration
rake test:integration

d) Run tests for units
rake test:units

Testing within Aptana RadRails
1) Select the Rails Project that is to be tested
2) Click the Tests Icon on the ToolBar Nb. Y0u have a choice to select All Tests, Unit Tests, Functional Tests and Integration Tests
3) If you select Unit Tests, you should see a dialog window showing progress with an option to run in the background.

4) On competion of the test, you should see the following result :-

Available assertions for rake test:units

assert_kind_of Class, @var # same class
assert @var # not nil
assert_equal 1, @p.id # equality

@product.destroy
assert_raise(ActiveRecord::RecordNotFound) { Customer.find( @customer.id ) }

Available assertions for rake test:functional

a) Requests

get :action # a get request of the specificed action

get :action, :id => 1,
{ session_hash }, # optional session variables
{ flash_hash } # optional messages in the flash
post :action, :foo => { :value1 => 'abc', :value2 => '123' },
{ :user_id => 17 },
{ :message => 'success' }
get, post, put, delete, head
assert_response :success

# possible parameters are:
# :success
# :redirect
# :missing
# :error

b) Redirects
assert_redirected_to :action => :other_action
assert_redirected_to :controller => 'foo', :action => 'bar'
assert_redirected_to http://crm4web.com.my/

c) Rendered with Template
assert_template "post/index"

d) Variable Assignments
assert_nil assigns(:some_variable)
assert_not_nil assigns(:some_variable)
assert_equal 11, assigns(:posts).size

e) Rendering of Specific Tags
assert_tag :tag => 'body'
assert_tag :content => 'Rails Plugins'
assert_tag :tag => 'div', :attributes => { :class => 'index_list' }
assert_tag :tag => 'head', :parent => { :tag => 'body' }
assert_tag :tag => 'html', :child => { :tag => 'head' }
assert_tag :tag => 'body', :descendant => { :tag => 'div' }
assert_tag :tag => 'ul',
:children => { :count => 1..3,
:only => { :tag => 'li' } }

More to come...

Rails Basics : Useful Helpers

2007-10-31T21:40:00.002+08:00

In developing the e-CRM, I have found the following helper methods very useful :-

a) Hardcoded select list

def severity_form_column (record, name)
select_tag name, options_for_select(%w(Show-stopper Severe Nice-to-have Customisation Trivial), record.severity)
end

b) TextArea for edit/create

def blog_form_column(record, input_name) text_area_tag('record[blog]', @record.blog, :size=>"80x30")
end

c) checkbox for edit/create

def active_form_column(record, input_name)
check_box :record, :active, :name => input_name
end

e) checkbox for list
def active_column(record)
check_box_tag 'active', 1, record.active?, { :disabled => true }
end

f) date display for list
def bill_date_column(record)
if record.bill_date.nil?
record.bill_date= '-' #''&nbsp'
else
record.bill_date.strftime("%d/%m/%y")
end
end

g) Customising Rails date format

def mydate_form_column(record, input_name)
date_select(:record, :mydate :order =>
[:day, :month, :year], :start_year => 1970, :end_year => 2000)
end

h) Controlling Text Field Size

def name_form_column(record, input_name)
text_field_tag('record[name]', @record.name, { :autocomplete => "off", :size => 40, :class => 'text-input'})
end

Advanced Rails : Why you should not use Global Variables ! [Updated 12th Sept 2009]

2007-10-28T09:51:00.005+08:00

What are global variables in Ruby ?

A global variable has a name beginning with $. It can be referred to from anywhere in a program. Before initialization, a global variable has the special value nil.

Global variables should be used sparingly. They are dangerous because they can be written to from anywhere. Overuse of globals can make isolating bugs difficult; it also tends to indicate that the design of a program has not been carefully thought out. Whenever you do find it necessary to use a global variable, be sure to give it a descriptive name that is unlikely to be inadvertently used for something else later (calling it something like $foo as above is probably a bad idea).

When a global variable has been rigged to work as a trigger to invoke a procedure whenever changed, we sometimes call it an active variable. For instance, it is useful for keeping a GUI display up to date.

There is a collection of special variables whose names consist of a dollar sign ($) followed by a single character. For example, $$ contains the process id of the ruby interpreter, and is read-only. Here are the major system variables and their meanings (see the ruby reference manual for details):

$! latest error message
$@ location of error
$_ string last read by gets
$. line number last read by interpreter
$& string last matched by regexp
$~ the last regexp match, as an array of subexpressions
$n the nth subexpression in the last match (same as $~[n])
$= case-insensitivity flag
$/ input record separator
$\ output record separator
$0 the name of the ruby script file
$* the command line arguments
$$ interpreter's process ID
$? exit status of last executed child process

In the above, $_ and $~ have local scope. Their names suggest they should be global, but they are much more useful this way, and there are historical reasons for using these names.

Why you should not not use Global Variables

Let us assume that on login (say using Acts As Authenticated), you may be tempted to initialise say $is_admin = current_user.isadmin and then use $is_admin to control access to modules or whatever. This will work very nicely in development mode or even production mode under say Apache 2.x + 1 mongrel process.

However, once you use Apache 2.2x + a pack of mongrel processes, your security measure will fail miserably ! Why ?

Prior to using Apache+a pack of mongrels, I was succesfully using a home-made role-based authentication in conjunction with AAA.

What I did basically was to add roles in users (AAA table) via adding fields (such as is_admin, is_marketing, is_finance etc). The result is that a user can can have one or many roles.
With this concept, I could control access to modules using layouts and within each controller or model I can control access to specific actions.

1. Control access to specific actions via controller.

EXAMPLE in customers_controller.rb
layout 'customers'
active_scaffold :customer do config

if User.current_user.is_admin
config.nested.add_link("Receivables", [:receivables])
end

2. Control access to specific actions via model

has_many :receivables

def authorized_for_update?
current_user.is_finance
end

def authorized_for_destroy?
current_user.is_admin
end

Using 1-3 works perfectly on Apache+1 mongrel on a Windows 2003. But once I activate Apache + 2 or mongrels, the whole security system got thrashed !

Response from Jan (Mongrel FAQ)

Globals are not shared across different instance of mongrel. To have a global appear in all instances you need some form of permanent storage (filesystem or database). If it doesn't need to change over the lifetime of the program you can pass in the global at startup in an environment variable.

You would not want to use a global in this case, since it needs to change after start up and the other mogrels would not be aware of the change. Use permanent storage. File system, database, or perhaps even a cookie

Response from Luis (author of mongrel windows service)

As Jan pointed, global variables aren't shared across processes.
You need rely your authorization schema in something else instead a global variable, since 2 users could hit the same mongrel instance and both get great as admin.
You need to investigate further about authorization schemas and how session is handled (and could be used for your purpose).

First you need to move your session storage to ActiveRecord or cookie based (in case of 1.2.5 or edge). Then I suggest you take a look at the following plugins for Authentication:

RESTful Authentication:
http://railsify.com/plugins/3-restful-authentication

Acts as Authenticated: http://technoweenie.stikipad.com/plugins/show/Acts+as+Authenticated

Later you will need some role management (to handle is_admin?) Take a look at the suggestion and the "Elsewhere" part from the Acts as Authenticated stikipad page.

My solution was to use the role_requirement plugin by Tim Harper.

This link is also relevant to our discussion here.

Rails Basics : All about Validations

2007-10-27T11:41:00.002+08:00

Irrespective of languages, frameworks and platforms, one cannot run away from providing validations to data input. How does Ruby on Rails do it ?

To be precise, Active Record, an integral part of RoR, provides validation support as follows :-

a) validates_acceptance_of(attribute, :message => "message", :accept => "1")
b) validates_confirmation_of(attribute, :message => "message")

c) validates_exclusion_of(attribute, :in => enumerable_object, :message => "message")
d) validates_inclusion_of(attribute, :in => enumerable_object, :message => "message")

e) validates_length_of(attribute, :maximum => max, :allow_nil => true, :message => "message")

f) validates_length_of(attribute, :minimum => min, :message => "message")
g) validates_length_of(attribute, :in => range, :message => "message")

h) validates_numericality_of(value, :message => "message")

i) validates_presence_of(attributes, :message => "message")

j) validates_size_of(attribute, :maximum => max, :message => "message")
k) validates_size_of(attribute, :minimum => min, :message => "message")
l) validates_size_of(attribute, :in => range, :message => "message")

m) validates_uniqueness_of(attributes, :message => "message", :scope => "condition")
n) validates_uniqueness_of(attributes, :message => "message", :scope => "condition")

Rails Basics : I am a newbie, what should I read ?

2007-10-20T11:04:00.003+08:00

Just like thousands of experienced programmers who have flocked to Ruby after seeing the incredible demo on how easy it was to create a Ruby on Rails Applications, I started on RoR and after a short while, I hit a road block :-(

What did I do next ?

Consistent with I did when I started by programming career via Clipper, I went to my favourite bookshop and bought all the Rails and Ruby Books available.

What I bought include :-

Dummies Guide to Ruby and Rails
Rails Cookbook
Ruby Cookbook
Rails Solution
Agile Web Development with Rails
Ruby on Rails : Up and Running
Rails Recipes
The Ruby Way : 2nd Edition
Active Record

Updated on 30th August 2009
    Programming Ruby
The Rails Way
    Rails Space
    Rails for .NET Developers (August, 2009)

Migration : Upgrading Rails from 1.2.3 to 1.2.5

2007-10-13T17:18:00.002+08:00

Being adventurous having my first Rails appplication in production since August 2007, I read about the impending Rails 2.0 release. As I understand it, there was to be a 1.2.4 release and it was supposed to be mostly made up of security fixes and deprecation notices that will help you prepare for Rails 2.0.

Being cautious, I froze Rails 1.2.3 into the Vendor Directory using rake:freeze:gems.

Then I gem install rails --include-dependencies

Surprise...Surprise, the update is to Rails 1.2.5 !

D:\Aptana_Workspace\crm4web>gem install rails --include-dependencies
Need to update 22 gems from http://gems.rubyforge.org
......................
complete
Successfully installed rails-1.2.5
Successfully installed activesupport-1.4.4
Successfully installed activerecord-1.15.5
Successfully installed actionpack-1.13.5
Successfully installed actionmailer-1.3.5
Successfully installed actionwebservice-1.2.5
Installing ri documentation for activesupport-1.4.4...
Installing ri documentation for activerecord-1.15.5...
Installing ri documentation for actionpack-1.13.5...
Installing ri documentation for actionmailer-1.3.5...
Installing ri documentation for actionwebservice-1.2.5...
Installing RDoc documentation for activesupport-1.4.4...
Installing RDoc documentation for activerecord-1.15.5...
Installing RDoc documentation for actionpack-1.13.5...
Installing RDoc documentation for actionmailer-1.3.5...
Installing RDoc documentation for actionwebservice-1.2.5...

Result :
Tested on a blank project (Radrails+Windows 2003 server) created using Rails 1.2.3
Can display the Std index.htm but on clicking the "About Your Application's Environment", the following error message was shown

"Routing Error, no route found to match /rails/info/properties with (:method :Get)

I then created a new project under Rails 1.25 and on clicking the "About Your Application's Environment"

About your application’s environment
Ruby version 1.8.6 (i386-mswin32)
RubyGems version 0.9.2
Rails version 1.2.5
Active Record version 1.15.5
Action Pack version 1.13.5
Action Web Service version 1.2.5
Action Mailer version 1.3.5
Active Support version 1.4.4
Application root D:/Aptana_Workspace/test-125
Environment development
Database adapter mysql

Worried about the impact on my Production Apps, I committed to SVN, unfroze and ran the app under Rails 1.2.5 and voila no problems :-)

BTW, I was just just informed of this link :-
http://weblog.rubyonrails.org/2007/10/12/rails-1-2-5-maintenance-release

which recommends as follows :-

To upgrade, `
gem install rails`,
set RAILS_GEM_VERSION to ‘1.2.5’ in config/environment.rb, and
`rake rails:update:configs`.

Updated on 18th October 2007

An example of a deprecation woud be
record_type => record.type.name

which will genenerate a
warning: Object#type is deprecated; use Object#class

Solution : record_type => record.class.name

Advanced Rails : Moving an Existing Database to a Rails Application

2007-10-11T17:40:00.003+08:00

Assuming that you have an existing application that you wish to rewrite in Rails, how would you prepare your database schema so that you can take advantage of the magick of db:migrate ?

Well, I had to do exactly that when I decided to rewrite an existing 200+tables CRM solution into e-CRM, a Rails application. This is what I did :-

a) Pluralize all the table names

Tip: One legacy table was named customer. To pluralize it to customers whilst retaing the data, I use CREATE TABLE customers SELECT * FROM customer for MySQL

b) Add an id field (auto-increment, integer) to every table

c) Add created_at, updated_at in every table to take advantage of Rails automatic updating of these fields without a single line of code

d) Added another magic column ie lock_version (must default to 0) to invoke optimistic locking

e) To support a belongs_to relationship, add belongs_to_tablename

f) Create a schema_info table with just 1 field ie Version, Integer and add a single record with the value=1

g) Use Rake db:schema:dump to create a schema.rb based on the underlying database schema . See following snapshot of Radrails in action

h) Create an empty migration file say 001_migrate2mysql and copy the contents to the Self.Up Method as shown in the Radrails snapshot as follows :-

That's it !
Updated on 4th November, 2007.

Active Scaffold : Roll your own form_ui ?

2007-10-07T11:50:00.001+08:00

In the trunk version or the soon-to-be released 1.1 release, we can configure columns, on a per controller basis, such as :select, :calendar, :textarea and :checkbox but what about :text_input ?

Previously, to control the width of a given text-input column, I had to put in the helper something like this either in application.rb or controller_helper.rb

def faq_form_column(record, input_name)
text_field_tag('record[faq]', @record.faq, { :autocomplete => "off", :size => 60, :class => 'text-input'})
end

Now, I can do this :-

config.columns[:biz_name].options = { :autocomplete => "off", :size => 30, :class => 'text-input'}

config.columns[:biz_name].form_ui = :tex-input

How is this done ? Simple, just add this method once in applcation_helper.rb

def active_scaffold_input_tex-input(column, options)
text_field :record, column.name, options
end

Yes, you can roll your own form.ui :-)

Rails IDE: I can't imagine why some people keep promoting Aptana

2007-10-06T17:10:00.003+08:00

In a post on borland.public.3rdrail.ide, Joe McGlyn, Product Development Manager at CodeGear made this comment in response to one of my post.

Joe :
I've spent the past few days trying to use RadRails (the newest M7 from > Aptana). I'm certainly strongly biased toward 3rdRail

CCH: This is to be expected, no worries :-)>

Joe:
but I'm reasonably objective too. If someone points out a bug or >shortcoming in 3rdRail that is valid I'm inclined to agree. Example: Diego's questions about our debugger -- it's weak. Got it, we'll have something that will rock in our December update.

CCH: I have noticed that in your response to my posts. That's why I respect you.

Joe : I can't imagine why some people keep promoting Aptana.

CCH: I think they promote RdRails rather than AptanaBTW, I will start to compile from the various posts why they do that ...and post it on my Rails Blog.

Joe : First, code completion: Method completion fails with a null pointer exception EVERYWHERE. I created a new project, re-installed the IDE, made sure the paths to the Ruby interp. and Rails + Rake commands were set right and it still fails everywhere. I've tried simple cases like "self." in controllers and actions, and modelname. in views, they all fail.

CCH:Just type self.+ctrl+space and a list was displayed (with no errors)Please do not be offended but did you install properly. There is an article on my blog "Rails...Rails...Rails"at http://cch4rails.blogspot.com/ which went live only yesterday and yes 3rdRail is also promoted.

Joe: The usage model is weak. Having to go to a combo box on a tabbed pane is lame. Having separate panes for installing a plugin

CCH: I agree on the inflexibility of installing plugins from unregistered sources vs. running a rake taskcch: I like the Rake Tasks Tab as I find it very convenientvs. running a generator is really week.

CCH: I prefer 3rdRail's Model wizard but the generate tab does have a destroy option which can roll back a controller/model which was requested in the 3rdRail FieldTest but I am not sure whether this has been implemented

Joe : It's a poor usage model, way less effective than working from the OS command line. There also isn't a keystroke to get to these magic views so everything is mouse-based.

CCH: This has not bothered me at all :-)>

Joe :Never mind that the "generator" combo box is buggy (after a bit of usage it's empty and I have to re-start)

CCH: I also find this mildly annoying but you do not have to restart, just click the Refresh icon on the top LH corner of the Generator Tab

Joe : The "gem manager" doesn't have any way I can find to install a plugin (install is always greyed out). I can't install a gem from a specific URL or svn tag (so, for example, it's useless for getting the Rails 2.0 > preview release) I can't add additional repositories to install gems from. Like most of the UI it ends up being a lot less useful than the command line.

CCH: I have just done that whilst installing the ibRuby Gem :-)See my latest article on Interbase at "Rails...Rails..Rails"

Joe : At first glance the debugger seems promising, and they have a list of refactorings, although most don't look that useful for Rails development.

Based on my research on comments made in popular RoR-related groups, this why some people keep promoting Aptana radrails

1) Tim Harper (Project Member : Active Scaffold) , 30th Sept 2007

Lemme chime in here and say I love aptana radrails.

I tried 3rdRail, and it felt "clunky". The code complete is excellent in it, but it's also pretty slow.

Aptana's code complete, go to declaration, combined with eclipse's textual complete are great enough for me.

Plus, radrails gives you a neat little tool for running unit tests that kicks the pants off running them in a console window

http://groups.google.com/group/activescaffold/browse_thread/thread/afed31fe981b6fe6/30e6785209ce5c73#30e6785209ce5c73

2. Josh

So it was definitely a ruby version issue. For some reason I was still running verion 1.8.2. I just upgraded to 1.8.6 and adjusting the aptana to work with it and now its working beautifully.

I'm willing to bet the other guy with the mac is running an older version as well.
http://groups.google.com/group/activescaffold/browse_thread/thread/9dba7977c325e9f0/95ce778341d5c154?lnk=gst&q=Aptana&rnum=14#

3) Patrick Aljord (8th March 2007)

RadRails is the best free IDE out there for RubyOnRails development and it's easy for companies to integrate it into their development platforms as it it's based on Eclipse.
http://groups.google.com/group/rubyonrails-talk/browse_thread/thread/73dd6d73752aa09b/59504f9e3488b88c?lnk=gst&q=radrails&rnum=3#59504f9e3488b88c

4) Chris Bloom (29th September 2007)

I'm using RadRails since I can't spring $2049 for TextMate (and accompanying Mac). I've also tested the "e" editor, and otherwise have used EditPlus.

RadRails is a nice balance of a compact work space, console/logger, and syntax hilighter. I also like its Auto-completion functionality, but it's anywhere from complete OR consistent. And it's preferences panel leaves much to be desired. Then again, it is still a beta release so you have to take some of those problems in context. I look forward to future releases.

http://groups.google.com/group/rubyonrails-talk/browse_thread/thread/fc4ec10f4767e4aa/0cf12c2fd2e323e9?q=radrails&lnk=nl&

5) John Lane (24th Sept 2007)

Hmm, I'd never heard of 3rdRail so I just checked it out: it appears to be a commercial product.

I personally use Aptana and, yes it has its issues but I think it's better to support an open source initiative with a donation than walk off to a close source solution.

However, if 3rdRail is streets ahead of Aptana then it may be worth paying for. So, what does it give that Aptana doesn't

6) Dr Nic (6th Nov 2006)

RadRails is a wonderful IDE for developing Rails/Ruby, and supports a similar auto-completion mechanism to TextMate's snippets, called templates. You activate them by typing a portion of the template name, and pressing CTRL-SPACE.

But RadRails doesn't come with many templates for Rails development.
I've just finished porting all the TextMate snippets across to RadRails - about 250 of them. I hope they are useful to other RadRails developers!
http://drnicwilliams.com/2006/11/06/post-halloween-radrails-trick-all-textmate-snippets-available/
Nic

http://groups.google.com/group/rubyonrails-talk/browse_thread/thread/9dbdeb357234c895/a1f35635bb6441fb?lnk=gst&q=radrails&rnum=23#a1f35635bb6441fb

7) Jay Levitt (1st Oct 2007)

integration support. Both RadRails and 3rdRail use the Subclipse plugin (though I suppose either could be made to use Subversive instead), so you'll see no differences between them.

I'm fairly happy with Subclipse; it's a bit finicky, and there are some cases (reverting, especially) where it's much slower than the command line, but the integration with the core Eclipse feature set is really nice - the ability to see in your project which files need updating, the Synchronize mode, and especially Mylyn's ability to automatically create separate changesets for each of your to-do tasks. Two of my favorite features are the Eclipse Compare Editor graphical merge view and the "Quick Diff" annotation bar[2] (which colors the line-number field for each line based on revision number and author, making it easy to find change groups).

The Subclipse maintainer is also on the core Subversion team, so I'd expect Subclipse to have terrific support for the cool new upcoming features in 1.5, like first-class changesets and merge tracking. In fact, he's blogged about a GUI merge-tracking client he's been working on[3].

http://groups.google.com/group/rubyonrails-talk/browse_thread/thread/be1f7ce2af0a5f18/1b0e136ee6b6adb1?lnk=gst&q=radrails&rnum=60#1b0e136ee6b6adb1

Active Scaffold : Brief Introduction...

2007-10-06T16:59:00.003+08:00

What happens when you have gone through the various tutorials and came away thoroughly impressed by how easy it is to develop a working RoR app ?

After a while, you will clearly decide that the default Rails Scaffolding though customisable is simply impractical. Why ? Think of a scenario where you have say a 200 tables CRM Win32 application which you are thinking of rewriting in RoR :-(

Enters Active Scaffold... In a nutshell, Active Scaffold is a Ruby on Rails plugin that dynamically creates user interfaces for your models that include your basic CRUD operations + search, a slick fully styled AJAX'ified design, and a high level of configurability. An extension of the AjaxScaffold project

Rails IDE : Why is 3rdRail Unique ?

2007-10-04T04:26:00.002+08:00

This is quoted verbatim from a response to post I made in the CodeGear 3rd Rail Public News Group.

CCH: As I delve deeper into eclipse-based IDEs such as 3rdRail & Radrails, I began to realise that a lot of features that developers rave about are actually from Eclipse. I am planning to write an impartial article (at > http://cch4rails.blogspot.com/) on why 3rdRail is so special, which I believe to be true to a certain degree. As such, I would appreciate it if you list the non-eclipse features that truly distinguishes 3rdRail from other IDEs .

Joe McGlyn, Director of Product Development, CodeGear :

Top level features:
- Rails Explorer
- Project Commander
- Ruby console
- Rails console
- Dependency view
- Rails refactorings (NB claims to have refactorings for views and actions, but it fails in every test case I've tried)
- Solid code completion (FWIW, I get a null pointer exception in RadRails M7 in nearly every test case on code completion -- not template completion)
- Context-aware templates (template expansion only shows templates for the current Rails context so you don't see view templates in a controller for example)
- "open associate" navigation according to Rails' dispatch rules

Using Interbase 2007 in Ruby on Rails Project

2007-10-03T20:33:00.003+08:00

Joe McGlyn, Director of Product Management at CodeGear has shown the way to use Interbase 2007 in Ruby on Rails as follows :-

Assuming you already have a project, here are the basic steps to modifying a project to work with InterBase as the database...

1. Get the InterBase gem
gem install ibruby

Comments by CCH :
There are a few ways to do this
a) c:\instantrails\ruby\bin >gem install ibruby

b) In Aptana RadRails,
i) call up the Gems Manager from
Windows\show view\Ruby Gems
ii) Within the Gems Manager
- Click Install
- select ibruby Gem

You can then see the progress within the Console Tab

c) In 3rdRail, you can use the Project Commander

2. Get the Rails adapter (from the root dir of your rails app or from the project commander) script/plugin source http://ibruby.rubyforge.org/svn/rails_plugins/trunk/
script/plugin install ibrails_plugin

Comments by CCH
a) Shell to Command prompt and cd to root of your project folder

c:\project_name>ruby script/plugin source http://ibruby.rubyforge.org/svn/rails_plugins/trunk/
c:\project_name>ruby script/plugin install ibrails_plugin

b) Using Aptana Radrals,
i) select the Rails Plugins Tab
ii) select ibruby and click Go

Nb. If ibruby does not show in the list, revert to method (a) :-)

c) In 3rdRail, you can use the Project Commander

NOTE :
You will also need to add these two lines into your Rails
environment.rb file:
# ------ force InterBase support to be added to Rails
# ------ as Rails currently has no way of extending its db
# ------ support apart from a new Rails release!
require 'active_record'
require 'vendor/plugins/ibrails_plugin/lib/ibrails_plugin'
# ------
Ideally these two lines should appear after the line loading
boot.rb which typically looks like this:
require File.join(File.dirname(__FILE__), 'boot')
and before anything else gets done (particularly any
initialization)

3. Assuming you have IB installed, and have the default IB user/pwd enabled you're good to go.
It will even create the database file (within your project directory by default)
Known limitation:Indicies are limited to ~200 characters, depending on how they are composed. This is InterBase, not the integration.

Comments by CCH

Despite religously following the instructions from Joe McGlyn of CodeGear, I have not been able to overcome the barrier and error message
ie "database configuration specifies nonexistent interbase adapter"
You may want to read the thread "Using Interbase with RoR" started by Joe here borland.public.3rdrail.ide

Rails IDE : Aptana Radrails M7 Beta - First Impressions

2007-10-02T21:43:00.002+08:00

I am an intensive user of Aptana Radrails M5 since July 2007 and have just updated to M7.

Interface-wise, I can immediately see the following changes :-
1) Rails Navigator has been replaced by Ruby Explorer
2) 5 obviously new icons on the tool bar
a) H - switch to Helper
b) T - switch to Test
c) M - switch to Model
d) V - switch to Views
e) C- switch to Controller

Curious, I selected my favourite project and click (a) - (e), nothing happened

Then, I opened the CustomerController which looks the same as in M5

Clicking H opened module customers_helper.rb
Clicking M opened module customer.rb
Clicking V asked for which action (using AS, N/A)
Clicking T opened customer_controller_test.rb

This is very convenient, Cool :-)

3) Rails Plugin no longer automatically goto the home pages but links are clearly there thus speeding up

4) Code completion/Code Snippet when one type

val or validates+ctrl+space displays a list wnd when selected inserts
validates_presence_of(attributes, :message => "message")

5) The Ruby Explorer is great in that via a tree structure, methods hyperlinked to the actual methods. This is a nice feature absent in M5.

This article was first posted on 28th September 2007, 11:30pm on the Ruby on Rails:Talk Google Group

http://groups.google.com/group/rubyonrails-talk/browse_thread/thread/e4365a0d52403271#

Rails IDE : Aptana Radrails M7 Beta - Best Way To Upgrade

2007-10-02T21:18:00.002+08:00

Just upgraded smoothly to long overdue Aptana M7 Beta which was released on 25/9/2007.

FYI, the best way to upgrade from July's M5 (M6 was skipped) is as follows :-

1) Click Help/Software Upgrades/Final and Install

2) Manually adding the following remote update site to the update manager: http://update.aptana.com/update/rails/beta/3.2/site.xml
Nb. Name the new remote site as say "Aptana M7 Update"

3) If you have any issue after upgrading, you could try to reinstall as follows :-
1) Remove the Aptana folder under C:\Documents and Settings\username\My Documents (if any)
2) Uninstall Aptana from Control Panel
3) Install from Aptana_IDE_Setup.msi
4) Goto Help\Software Updates\Find and Install
5) Accept the default Search for new features to install
6) Check Aptana M7 Beta and click Finish

This article was first posted on 28th September 2007, 10:48pm on the Ruby on Rails:Talk Google Group

Update on 4th October 2007

This is what I did to get a clean installation of RadRails
1) Uninstall va control panel
2) Delete Documents and Settings\username\mydocuments\Aptana Beta folder which contains the meta data
3) Remove the Programs\Aptana direcory
4) Install Aptana_IDE_setup.msi

Nb. You may want to chose custom and select to install JRE 1.6
I believe this is the source of your null pointer issue

5) Using Plugins Manager or Find and Install Software, install
- Radrails M7 Beta
- Subclipse

That's it

Why Rails...Rails...Rails ?

2007-10-02T20:19:00.002+08:00

In 1995, I started the popular Clipper...Clipper... Clipper website (no blogs then) which was very popular and linked by virtually every Clipper-related site. When I switched to Windows via Delphi in 1997, I started the Delphi... Delphi... Delphi site.

In June 2007, I discovered Ruby on Rails and no prize for guessing what I am gonna name this blog :-)

BTW, I started this blog on 30th September 2007 and this is the first Rails app which is a rewrite of a 200+ tables CRM apps on the Win32 platform.