Are you looking for my non-technical blog?

This is now my technical-only blog, my non-technical blog is here.

08 June 2012

Quick Intro to Ruby on Rails

There are a lot of tutorials and Getting Started guides, but I still need to write, not really a tutorial, but consider it as me taking notes of what I am learning so far, focusing mainly on Rails CLI.

Installing Rails:
$ gem install rails

Creating You Application (let's call it myblog)
$ rails new myblog
This will create a new folder with some stuff in there, i.e. your project folder.

To Run the Rails Server
$ rails server

What Are Rails Generators?
$ rails generate --help
Usage: rails generate GENERATOR [args] [options]

You can watch this Webcast about Rails3 Generators and then come back here l8r...

Types of Generators:


Generating Controller:
$ rails generate controller --help
$ rails generate controller CreditCard open debit credit close

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 and invokes helper, template engine and test framework generators.

`rails 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

Scaffold Generator
$ rails generate scaffold --help
  rails generate scaffold NAME [field[:type][:index] field[:type][:index]] [optons]


According to Wikipedia, Scaffolding is a technique supported by some model-view-controller frameworks, in which the programmer may write a specification that describes how the application database may be used. The compiler uses this specification to generate code that the application can use to create, read, update and delete database entries, effectively treating the template as a "scaffold" on which to build a more powerful application. [I.e. It creates tables, fields, and web forms to edit those tables, etc.]

Scaffolds an entire resource, from Model and Migration to Controller and Views, along with a full test suite. The resource is ready to use as a starting point for your RESTful, resource-oriented application.

Pass the name of the model (in singular form), either CamelCased or under_scored, as the first argument, and an optional list of attribute pairs.

Attributes are field arguments specifying the model's attributes. You can optionally pass the type and an index to each field. For instance: "title body:text tracking_id:integer:uniq" will generate a title field of  string type, a body with text type and a tracking_id as an integer with an  unique index. "index" could also be given instead of "uniq" if one desire  a non unique index.

# Database configuration are stored in config/database.yml 
# To create the actual database, use the following commnad:
$ rake db:create

Gemfiles [In Application Home Directory]

Gemfile (and Gemfile.lock): These files allow you to specify what gem dependencies are needed for your Rails application.
$ bundle install  # Use this command to install newly added gems 

Some Ruby Tips
Since I don't speak ruby, here are some things I stumbled upon today
$myVar ==> Global Variable.
:myVar ==> I have no idea what's that, they call it Symbol, looks like constant string or something.

That's all folks for today.