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

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 Basics : What is a Model ?

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 ?

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$