Pranshu Arya's List: Ruby on Rails

• 
   You'll need to retrieve the records again, or pass them in from params
   or the session. Instance variables do not persist between controller
   method calls (because the controller is freshly instantiated each time a
   request is made).

• Your projects collection (in the index action) is still available in the instance variable @projects and your project resource (all other actions) is available as @project

• In your views, you will get the following helpers: 

   

      resource        #=> @project     collection      #=> @projects     resource_class  #=> Project 
• collection (@projects instance variable) is only available on index actions
• in your views you will have @users and @user variables, but the routes used will still be accounts_url and account_url. If you plan also to change the routes, you can use :route_collection_name and :route_instance_name
• If you want to customize how resources are retrieved you can overwrite collection and resource methods. The first is called on index action and the second on all other actions.
• The end_of_association_chain returns your resource after nesting all associations and scopes
• super do |format|
• destroy! do |format|
• when you give a block which expects one argument it will be executed in both scenarios: success and failure. But If you give a block that expects two arguments, the first will be executed only in success scenarios and the second in failure scenarios.
• For example, if you want urls like /projects/:project_title/tasks
• :finder => :find_by_title!, :param => :project_title
• It also accepts :route_name, :parent_class and :instance_name as options

10 more annotations...

• @page_results = WillPaginate::Collection.create(current_page, per_page, @results.total_results) do |pager|  pager.replace(@posts.to_array) end

  • to_array is now to_a
  Add Sticky Note
• WillPaginate::Collection extends Array class and added properties like @current_page, @per_page, @total_entries etc. We pass the current_page, per_page properties in constructor and we replace the array contents by converting our @posts to an array (@posts.to_array). This is assuming that @posts contains only the collection for current-page.

  • to_array is now to_a
  Add Sticky Note

• Like variables hold data, procs hold the code itself
• As a proc is just another object, it can be passed around in methods, returned by methods etc.
• Bl

  ocks like procs are used to pass code to methods, but they are like undefined procs. ie they are not assigned to any variable, they are just passed to the methods.
• They can be passed to any method, the method may or may not use them.
• The method can call the block, by giving the command “yield” which executes the code in the block.
• Blocks can be passed along with the other parameters of the method.
• Blocks can accept parameters like methods
• Ampersand is used to convert a proc to a block and a block to a proc.
   If a method want to accept a block but wants to use it as a proc, then add an & in front of the last parameter(the parameter which will receive the block.
• Only one block can be accepted by a method.
• A block can be passed to any method, no need to define it.

8 more annotations...

• Like classes, modules are bundles of methods and constants.
  Unlike classes,  modules don’t have instances; instead, you specify that you want the  functionality of a particular module to be added to the functionality of a  class, or of a specific object.
  
  
• It’s no accident that modules are similar in many respects to classes: The class  Class is a subclass of Module. Judging by the family tree of  classes, class is a specialized form of  module.
  
• modules get mixed in to classes.
  When this happens, the instance of the class  has the ability to call instance methods defined in the module.
  
• Modules are sometimes referred to as mix-ins.
  
  The mix-in operation is  achieved with the include  statement. include is actually a  method.
  
  
• you can mix in more than one module
• No class can inherit from more than one class. In cases where you want numerous  extra behaviors for a class’s instances—and you don’t want to stash them all  into the class’s superclass—you can use modules to organize your code in a more  granular way. Each module can add something different to the methods available  through the class.
  
  

4 more annotations...

• Each rails UJS AJAX call provides six custom events that can be attached to:

   
   
  • ajax:before – right before ajax call
   
  • ajax:loading – before ajax call, but after XmlHttpRequest object is created)
   
  • ajax:success – successful ajax call
   
  • ajax:failure – failed ajax call
   
  • ajax:complete – completion of ajax call (after ajax:success and ajax:failure)
   
  • ajax:after – after ajax call is sent (note: not after it returns)

• When you Include a module into your class as shown below, it’s as if you took the code defined within the module and inserted it within the class, where you ‘include’ it.
• The load method is almost like the require method except it doesn’t keep track of whether or not that library has been loaded.
• when using the load method you must specify the “.rb” extension of the library file name
• if your module changes its state frequently, you may want to use load to pick up those changes within classes loaded from
• The require method allows you to load a library and prevents it from being loaded more than once. The require method will return ‘false’ if you try to load the same library after the first time.
• When using the extend method instead of include, you are adding the module’s methods as class methods instead of as instance methods.

4 more annotations...