About us   Registration   Site map    
 
         
   
      New user|Forgot password  
 
   
 
 
Select Your Country to check the Schedule for this Course
Country:  
Time Zone:
   
PAYMENT METHODS
PAYPAL GOOGLE CHECKOUT
Course Name Course Code
Ruby On Rails 82
Course Contents

Ruby Language Skills and Techniques

 Running Ruby

            Command-line Ruby

            The Interactive Ruby (irb) console

 Objects, variables, and methods

            Basic object-orientation concepts

            Naming conventions

            Variable assignment

            Local vs. instance variables

            Life of different variables in methods

            Method-calling semantics

 Method arguments and return values

 Classes and modules

            Instantiating classes

 Polymorphism in ruby

            Mixing in modules

 Built-in classes

            String

            Array

            Hash

            Symbol

            Numerics

 Blocks and iterators

 

            Blocks vs. methods vs. lambdas

            Collection iteration

            Single-object iteration

 Exceptions

            Built-in exceptions

            Writing your own exception classes

            Exceptions in Rails

ActionController

Controller Actions and View Templates

Basics of controller/view interaction

            Creating controllers and view with "generate"          

            Default rendering rules

            Shared controller/template instance variables

            Separating controller logic from view specifics

 HTML templating with Embedded Ruby (ERb)

            Rules of ERb processing

            Layouts

            Using master and partial templates

 Fine-tuning controllers and view

 Controller filters

 Redirecting control

 Default and custom view helper methods

 Writing and processing HTML forms in Rails

            Using form helper methods

            "Magic" field initialization from instance variables

            Accessing CGI data through the "params" hash

 Ajax calls and RJS (Ruby/JavaScript) templates

            Basic DOM updating with Ajax

            Using RJS for composite Ajax calls

            Render different formats

 Routing

            Purpose of routes

            Writing routes for the rails app.

            Types of routes and usage.

ActiveRecord

Model Design and Database Management

 Domain modeling for Rails and Ruby

 Describing the "what" of the application

 Creating ActiveRecord models with "generate"

            Object-relational mapping with ActiveRecord

            ActiveRecord models and Ruby classes                    

 ActiveRecord associations

            The Association Hierarchy

            One-to-Many Relationships

            The belongs_to Association

            The has_many Association

            Many-to-Many Relationships

            has_and_belongs_to_many

            has_many :through

            One-to-One Associations

 Migrations

            Creating Migrations

            Naming Migrations

            Migration Pitfalls

            Migration API

 create_table(name, options)

            Defining Columns

            Column Type Mappings

            Column Options

            Decimal Precision

            Column Type Gotchas

            Custom Data Types

            “Magic” Timestamp Columns

            Macro-Style Methods

            Relationship Declarations

 Convention over Configuration

            Pluralization

            Setting Names Manually

            Legacy Naming Schemes

 Defining Attributes

            Default Attribute Values

            Serialized Attributes

 CRUD: Creating, Reading, Updating, Deleting

            Creating New ActiveRecord Instances

            Reading ActiveRecord Objects

            find

 Reading and Writing Attributes

            Hash Notation

            The attributes Method

            Accessing and Manipulating Attributes Before They Are Typecast

            Reloading

 Dynamic Attribute-Based Finders

            Custom SQL Queries

            The Query Cache

            Logging

            Default Query Caching in Controllers

 Updating

            Updating by Condition

            Updating a Particular Instance

            Updating Specific Attributes

            Convenience Updaters

            Controlling Access to Attributes

            Deleting and Destroying

 Session Management in Rails

 Advanced Finding

            Conditions

            Ordering of Find Results

            Limit and Offset

            Select Option

            From Option

            Group By Option

            Locking Option

            Joining and Including Associations

            Read Only

  Validations

            The Simple Declarative Validations

            validates_acceptance_of

            Error Message

            The accept Option

            validates_associated

            validates_confirmation_of

            validates_each

            validates_inclusion_of and validates_exclusion_of

            validates_existence_of

            validates_format_of

            validates_length_of

            validates_numericality_of

            validates_presence_of

Helpers

            ActiveRecordHelper

            Reporting Validation Errors

            error_message_on(object, method, prepend_text = “”, append_text = “”, css_class =“formError”)

            error_messages_for(*params)

            Automatic Form Creation

            form(name, options)

            input(name, method, options)

            Customizing the Way Validation Errors Are Highlighted

            AssetTagHelper

            Head Helpers

            auto_discovery_link_tag(type = :rss, url_options = {}, tag_options = {})

            image_path(source)

            image_tag(source, options = {})

            javascript_include_tag(*sources)

            javascript_path(source)

            stylesheet_link_tag(*sources)

            stylesheet_path(source)

        and more

ActionMailer Basics

Testing in Rails

 Purpose of testing

 Fixtures

            Accessing Fixture Records from Tests

            Dynamic Fixture Data

            Using Fixture Data in Development Mode

            Generating Fixtures from Development Data

            Fixtures Options

 Unit Testing

 Assertions

            Basic Assertions

            assert and deny

            assert_block

            assert_empty

            assert_equal and assert_not_equal

            assert_in_delta and assert_in_epsilon

            assert_include

            assert_instance_of

            assert_kind_of

            assert_match and assert_no_match

            assert_nil and assert_not_nil

            assert_same and assert_not_same

            assert_raise and assert_nothing_raised

            assert_respond_to

 Functional testing

            Assert That Variables Were Assigned Properly for Use by Templates

            Assert the HTTP Status Code of a Response and Its MIME Content Type

            Assert the MIME Content Type of a Response (or Other Header Values)

            Assert Rendering of a Particular Template

            Assert Redirection to a Specified URL

            Assert Setting of Flash Messages

            Assert Database Changes Resulting from Actions

            Assert Validity of a Model

            Asserting View Output

 

 

 Rails Integration Tests

            The Integration Test API

            assert_redirected_to(options = {}, message = nil)

            assert_response(type, message = nil)

            assert_template(expected = nil, message = nil)

  REST in Rails

            Coding REST methods

            REST url'S

            REST calls

PAYMENT METHODS
PAYPAL GOOGLE CHECKOUT