So Whats left in Rails???

Organising form in Rails:

     You can create forms in rails which is either associated with a particular model or independently which can be associated with an entity created.When it is to be associated with a model first create an object to that model in the controller action that precedes the invoking of the corresponding view file.For eg if you are making a form in the new.html.erb then we have to initialize the object in the new action in the respective control.If the new object is 

pro1=Profile.new 

then after that new function the new.html s invoked.On clicking the submit on this the create action is invoked on the respective controller.

ON the other hand if you give 

pro1=Profile.find_by_id(current_user.id)

then it understands that it should move on to the  edit because the profile whose values whom you are going to enter is already present in the table and so it is redirected to the edit.html page and on creating the submit in that form the "update" action is invoked directly.

An example is

def new

     @pro1=Profile.new

end

in the html

<% form_for @pro1 do |r| %>

<% r.label :name %>

<% end %>

In case of newprofile @pro1 will be a new object ,on the other hand it will have the profile that it found.

If the form is not associated with a model then you wont create an object and pass instead you give  form_tag.

<% form_tag ("/new") do %>

         <% label_tag :name %>

<%end %>

User Authentication:

      There are a number of gems which does the authentication.One very useful one is the devise which has the options for password confirmation,recovery,tracability,password hint all other validations etc.You can also create your own authentication function using the Bcrypt gem or any other gem or your own ones as you wish.Bcrypt hashes and then stores the password.

If you have to authenticate any user for a particular user then you can specify it in single line  as shown

       http_basic_authenticate_with :name => "dhh", :password => "secret", :except => [:index, :show]

 Sessions:

     This can be accomplished by
->Session attribute -Just give sessions[:user_id]=user.id
and access it.THis remains as an internal hash.

     What kind of sessions to use??
->If session hash is created it can be created in the cookie and is vulnerable.It can be destroyed or stolen.
->Dont store large values in cookies.


The most common methods implemented are 
ActiveRecord::SessionStore and ActionDispatch::Session::CookieStore.
 
ActiveRecord::SessionStore : In this method the session id and the hash in the database and retrieves it as and when necessary.

 ActionDispatch::Session::CookieStore-In this the session data is stored in the cookies.

This cookie storage is again vulnerable to replay attacks so better option is to store in the database.

 

Testing in Rails: 

   Rails follows test driven development.First you write a test case and then carry out the development such that all the test cases satisfy.

Test is an automatic way to verify the correctness of a method,class etc.It is isolated.Starts with 

describe "test_case1" do

//give the assertion here

end

There are a number of assertions like assert_equal,assert_not_equal etc.The above method can be used to test individual methods or functions.

Fixtures:

IN case you want to simulate the actions of the browser or mouseclicks like a client tests your app,you can use fixtures or Capybara

Bundler:

You can specify all the gems which you want to install in the gemfile and then give "bundle install".This downloads all the required gems from the source and installs it.The version conflict problem is resolved by including gems like this.

RakeFile: 

Rakefile allows you to run tasks using the application's environment. There are plenty of other non-rails things that rake is useful for. Its not something Rails specific and you can use any Ruby code in it. Rails and many gems use rake for things like migrations, cron jobs, and any other task that needs to run outside the application server.

Sql injections:

 "SQL Injection" is subset of the an unverified/unsanitized user input vulnerability ("buffer overflows" are a different subset), and the idea is to convince the application to run SQL code that was not intended. If the application is creating SQL strings naively on the fly and then running them, it's straightforward to create some real surprises.

SELECT fieldlist
  FROM table
 WHERE field ='$email'

suppose the user enters it as ronamari15@gmail.com'..Then the field entered becomes 'ronamari15@gmail.com'
'.This creates a problem in the db because of the quote in the email id,since the data we entered can be a part of

 the where clause. 

Deep into rails!!

Capistrano:

•         This is an open source tool for running scripts on multiple server.
•         Supports changing of databases quickly.
•         Written in ruby language and is distributed as rubygems .
•         It executes command on parallel on multiple systems via the SSH.
•         Capistrano was originally designed to simplify and automate deployment of web applications to  distributed environments.
• It can also deploy web applications that are even written in other languages like php etc though written in ruby.
• >install gem capistrano is the command to install the gem.

Named Routes:

   These are used to provide name to the routes ,so that it is more easily accessible and recognised.An eg goes like this,

    match "users/prof/new" => prof#new ,:as=>"routee".

Now if we have to access that particular page in the link give it as

        link_to goooo routeee_path..

Install gems in a better way:

Now as i was telling abt the various gems in ruby I told the method of installing gems as sudo install the gem_name.But that is not the best method.There will be some clashes based on the versions of ruby and the various gems versions.The better method and the one to be followed is to give the "gem "devise" in the Gemfile and then in the terminal give "bundle install"

Nginix Applications:

->Kind of web server

->Manages Http requests,allows concurrent access.

->Follows event driven approach rather than the thread driven approach and supports multiple instances of the same application

->other eg)Apache tomcat which we commonly use.

Passenger:

 The most commonly used application servers are Thin, Passenger and Mongrel.

It is a very powerful application server which is robust.It handles the request sent by the web server effectively.

Passenger is what is easy to configure and is recommended by rails.

The basic Application Flow:
When a http request comes first it hits the routes.rb file.There based on the routing of the resources you give the control leads to the page that is pointed to by the "root :to" field.Then first it strikes the controller and the specific action.Once the action is completed it goes to the specific html page in the views.To display new.html first new is executed,if the object is created in new then it invokes the "create" method after the execution of new.html.erb of that model on "submit".If it is a retrieved item then it triggers the" update "action in the controller.
         If you want to have full control with the flow you can redirect the application flow using "redirect_to " and "render".render doesnt invoke the controller and the model.It just renders the view."redirect_to" creates a http req goes through the model and the controller and with the result renders the view page.

Evolving your Database:1)Create the model 2)Create a database rake db:create 3)give rake db:migrate 4)make migrations and keep repeating the step 3 for each change to update.

Validations,and certain others!!

Validations:

    Validations can be either done in the front end using javascript or at the back end before putting the data in the server.Which is better??

If all validations are done in the javascript "Disable javascript option can remove the vaildations.But if all the validations are done by the server there will be overhead in the server.So a balance between the 2 should be accomplished.

      Various options that are available are 

:acceptance--->If it has to accept to the terms and agreement etc.

:uniqueness

:singularity

:associated--->If some association is defined and you want automatic validations among the various associations.

:confirm--->eg)confirm password.For example the db will not have 2 fields separately for confirm field but unless this checking is done the db insert or update wont be done.Automatically the confirmation field will be created using "fieldname_confirmation"

:confirm and :acceptance generally doesnt store anything in the database,But can be made to do so.

Exclosion:Accepting values that it wont accept.

Inclusion:Specifying within what it will accept.

:format--->LIke checking the formats for email and stuff.

NILL AND BLANK:

 a=nil

a.nil=true and a.blank=true

a=[]

a.nil=false

a.blank=true

You can also use "if" or "unless" along with validates..

Git:

This is a distributed revision control and version control with an emphasis on speed.If you have heard of subversion this is different from that.In subversion there is a central server from which you get your project make changes and again push it back into it.But git is distributed,and we can download a local copy into our system and make changes this change is applied only into the local copy.Only when you push it it goes into the main copy so that other users can pull it again.While working we can go pull the copy,make it merge and check with the merge conflicts and rectify it and then push it back.

Uses function like "clone" to make a local copy.Even im not sure of this but it is easy if we start working with it i guess.

Slim:

This is the simplified form of haml with no strict indentation issue.Read on to understand that.Haml is nothing but HTML substitute for erb.
Problem with Html:DRY-repeating yourself.
Solution:
HAML
Open and close tags are avoided in this.
<p id="qq">
Hello
</p>

becomes either
%p#qq

Hello

or
%p{id=>"qq"}

Hello

Indentation matters in HAML.Two space or a tab represents nested loops.The second method is better among the above because when the attribute "qq" has to change with runtime returning hashes are better.

->THis reduces code size and doesnt repeat unnecessarily.

->Each code in HAML is converted to HTML,so there is a very little time lag.

-->There are gems lik HAMLtohtml and vice versa to convert between them

SAAS:

This is simpler form of HAML.But this allows inheritance in the classes of the css scripts.

More on Rails!!

Rest:Representational State transfer.This is associated with resources.
What is a resource??Anything that is an entity and also allows and implemetnts Crud and index method.
What is a model??  Anything that interacts with a database is a model.In rails you need not create your database,nor establish access from the scratch.All this is automatically done by the ORM-object relation mapper.

What does an ORM do??It's job is to connect to the database.The attributes are mapped to the columns of the database and the classes are mapped towards the tables in databases.The objects of the classes are mapped to the records of the database.In the tables used in rails the foreign key and the primary key are not used to create the relationships.Instead it is abstracted and relationships are created by the means Associations in OOPS.

Some of the associations are-->has_one
-->has_many
-->has_and -belongs to many
-->belongs+to
In cases where you map 2 tables in a many-many relationship then you have to include an intermediate table to it.The intermediate tables will contain the id's of both the columns.We do not add a seperate id column to this because it is not actually necessary.When you make associations certain dynamic methods are created during the runtime,which is an instance of ruby programming.For ex if user and groups are associated then the methods such as "user.groups" and group.user are created.Assocaition in rails makes it very simpler to  use.

ActiveModel and ActiveRecord:
                         When you create a class,the model class inherits from the ActiveRecord.Active record allows you to access the db records,manipulate it and retrieve it and to perform the other logic necessary.It wraps a table inside an object.The mapping of the objects to rows,attributes to columns etc are done via this.When a new object is created a new row is creates.For instance
part=new Part
part.name="rr"
part.type="qq"
part.save
 will do
insert into part values("1","rr","qq");

Similarly it can also be used to query a database.

What is the ActiveModel then??!.It is the behaviour which allows the ruby objects to act like its active records,by adding validations,callbacks,naming conventions etc.
Activemodel doesnt relate to the tables in the database.

Consider a shopping cart table it can also be put directly in the payment table and paid status can be put to false,but it is a better practice to put it in a seperate table cos only then the dynamic methods like user.shop_cart can be accessed easily else we have to write queries checking for the required records.Also test classes are made simpler.

Callbacks in ActiveRecords:
This is an action performed directly after a DB action.Like a callback is called soon after an object is saved or before that.There are various such callbacks.After_initialize is another important callback.Callbacks are similar to triggers.To enable the proper working of callbacks Hooks are introduced.
To create A hook

create s_hook<ActiveRecord::Hook::Base
   Callbacks helps you in not  writing too much into the model and messing it up.Instead you can put it in the callbacks.When there are large number of callbacks then put it together into a observer.There are certain actions like "update_all"  which will not directly trigger the validations,must use such actions with great care.

Db:
schema.rb locks your db schema while executing.At each migration schema.rb is updated.
For Mongo db like db there is no Db.In such ORM's there is no migration associated with it,so no locking of schemas.

You can either inherit from Active_Record or include its modules.Which is better??When you inherit you are including a lot  of unwanted code.So it is better you include and use the necessary modules as necessary.

Now we will move on to actionpacks which contains Actionview and actionController.
ActionController is thr first to get hit when an request is sent.
What is applicationController??It contains the general settings,like
-->protect_from_forgery for the entire application
-->If signed in go to one page or the other page.
All other controllers are inherited from the application  controller.

Now we know what the application controller does ,so what does a action controller do>>
-->It has ability to call and use the actions
-->Enables code abstraction and so methods can be called as actions.

certain actions in a controller can also be made as a private action .But how will you cal them??Yes it can be called via another method.ie some other action can call this action.
But where exactly do we use private methods in a controller???I am yet to find the answer to this question,will come back with an answer very soon..

Yeahh and so there are many instances where you use private methods in a  controller.Such as if there are subsequent actions that should be done in some other database tables when some db action occurs it can be done in  private methods in a controller.But be sure that the subsequent db action you do is accessed only by self.

If you want to change from the actual form to some other form ,the flow is iven in your controller.You give it as
   render :action=>status
where status is the new view file name.

Render and Redirect_to:
     Render is only used to redirect to some other form.But when you give redirect you go to some other view,but the control goes to the controller and the model before rendreing this view.

Partials:
   Bunch of HTML code for reuse.
   Start s with an "_".

Do you find any instance in rails where you can easily see the block concept implemented.Yes in the layouts the html files basic layout will be given and in the body part the "yield" will be called and this part is given in the various views files.

Ruby on Rails! Part 2!!

Rails migration:

    Rails migration enables you to do the following.

-->If one person makes a change all the other person needs to do is to just update it and run in a team of developers.

-->When working with multiple systems migrations help in synchronization.

Rails migrations does the following things,

-->create table,drop table ,rename table

-->Add column,delete column,change column ,rename column

-->Add index and remove index extra.

They also support all the basic data types.

  --> Convenient way to alter your database in a structured and an organised manner.

-->For each an every alteration you do to a database,in terms of creation and updation it stores as an unique migration in db/migrate.

-->The name of the migration is based on the timestamp ending with the class name.If you want to change the class name chamge the name of the model else you will get an error saying "No class found".You can also rollback databases whenever you want to undo any new changes that you have created.

Creating the migrations:

It will be done directly on scaffolding.Other way to create is

               ruby script/generate migration table_name

You should use lower case for the table-name that is the rails paradigm.This will create a file in the db/migrate directory which has the structure of the table necessary.

Running the migration:

run db:migrate

As we create migrations we should also write code to rollback to its  

Scaffolding:

-->Enables us to find how the rails exactly works.

-->Quick code to demonstrate and get feedback on rails.

If you are using scaffolding to create a rails application all your work will become very easier.

If you dont use scaffolding you have to create the project,its model,its view and controller,the routing paths,the database ,you have to populate them etc.In using scaffolding all are automatically created .

All the CRUD functions,Create,Delete,Update and Retrieve functions are directly inserted into the controller and doesnt need to be manually added.

Configuring database.yml file :

     This is a very sensitive file.This displays the 3 different environment it offers and the various databases it uses along with the settings and the details.The username and the password for each of the db is also mentioned here.The spaces in this should be given carefully .Any extra space or error will not let you run the create db cmd like

   rake db:create

The above will give an error  "Rake aborted"

The console:

This can be accessed using the rails.console command.

The rails server is run using the "rails.server "command.

Configuring :

The config folder has all the configuration settings of the project.The routs file in that is used to specify where the control is to be redirectd.

What are helpers??

They are used when you have to do some small logic computation relating to the view.For example to get the full name of an user by the concatenating operator.The concatenation is done with the help of a helper.Only the view can access the helper methods.The helper methods are put in a module.The model functions can be accessed using the helpers but not directly.The objects are passed as arguments to the helper by the views,so that the helper can access it.

Simple start with Rails:

After knowing the few of the above basics i started creating a simple rails application using the below link

http://guides.rubyonrails.org/getting_started.html

Ruby Now on Rails!! Intro !

Rails Introduction:
-->Web application development framework written in ruby.
-->Less code can accomplish more than what other programming languages can do.
-->If we use it the right way it is the best,else if u try to bring the old programming practices into it ,it will end up as a big mess.
-->It is an open source framework for developing database backed web application.
-->No compilation phase is required.

Strength of Rails:
-->Metaprogramming : Other frameworks use extensive code generation from scratch. Metaprogramming techniques use programs to write programs. Ruby is one of the best languages for metaprogramming, and Rails uses this capability well.
-->Active Records:Rails have active record framework which saves objects to databases.
-->Convention over Configuration:No need of writing much configuration.If u follow the naming syntax properly,configuration is not necessary.
-->Scaffolding:You often create temporary code in the early stages of development to help get an application up quickly and see how major components work together.
-->Built in testing:Rails creates simple automated tests you can then extend. Rails also provides supporting code called harnesses and fixtures that make test cases easier to write and run.
-->Three environments:Rails provide three different environments,one for production then one for development and testing.There is a fresh database for testing for every test run.

Installing Rails:
1)First Ruby has to be installed.Then install the ruby gems using the command..
               sudo install rubygems
2)Then install the rails gem using
               sudo  gem  install rails--include-dependencies
Updating Rails:
Give
                rails update
Installation verification:
Give "rails demo".A demo project is created.Then give it as "http://localhost:3000".It should give the Welcome aboard or congratulations message.

Model View Controller Pattern:Model stands for all the business logic in the application involving the database.This subsystem is implemented in ActiveRecord library which provides an interface and binding between the tables in a relational database and the Ruby program code that manipulates database records. Ruby method names are automatically generated from the field names of database tables, and so on.Controller is what controls the flow.This subsystem is implemented in ActionController which is a data broker sitting between ActiveRecord and ActionView.And view is how the data is displayed on the screen.This subsystem is implemented in ActionView library which is an Embedded Ruby (ERb) based system for defining presentation templates for data presentation. Every Web connection to a Rails application results in the displaying of a view.The request is first sent to the controller and it redirects to the corresponding model which is then displayed on the screen.

The Architecture:


Directory Structure:
          You can access the directory structure of the demo project that  you created by using
                        C:\ruby\> cd demo

              C:\ruby\demo> dir

The models views and the controllers exist in the app folder in the structure.The config file has the route file which is used for routing r redirecting the file.This is the directory structure:
demo/
..../app
......../controller
......../helpers
......../models
......../views
............../layouts
..../components
..../config
..../db
..../doc
..../lib
..../log
..../public
..../script
..../test
..../tmp
..../vendor
README
Rakefile

What else in Ruby??? !!

Monkey patching:
      You have so many functions which are inbuilt in Ruby.This language is so flexible and lets you go and edit the functions for a particular program so that it can act as u want it to perform.This is called as monkey patching.This considerably increases the flexibility of Ruby ,which when over engineered may lead to many inconsistencies.

Array manipulations:
   You can change the way .each function executes by

class Array
def each
     puts "before printing"
     yield(self)
     puts "After printing"
end
end


a1=[1,2,3]
a1.each{|q| puts q}

Output:
before printing
1
2
3
After printing

This is just a simple manipulation ,you can manipulate it to do anything you prefer to.Similar manipulations can be done to Ranges to using the functions available to ranges.

Scope:
      There are different scopes available in Ruby.All methods are public by default.There are other access specifiers like protected,private etc.Both private and public are almost the same.The other details regarding the scope are already mentioned in the relative sections in the previous posts.

Iterators In Ruby:
  Iterators are something which is used to traverse through an array again and again repeatedly.For String class we have iterators like "each_byte" to traverse char by char and "each_line" to traverse between the different lines.For different classes different set of methods are provided.In low level lang like c while iterating  the string you should check for the termination char to give it as a condition but this doesnt require any internal knowledge of the atorage.

a.each{|q| puts q if  q<5}

Attributes:
I have already specified about the accessors that are used for accessing ruby attributes from outside the class.You can either use the predefined one or you can define your own attribute accessors.Both methods are specified in my previous posts.

Exception Handling:
Exception handler is a group of code that is executed when something goes not as expected.When an exception occurs it raises an exception which breaks the normal flow of operations.This exception is rescued by "rescue " and is handled.Any exception raised is an instance of class "Exception"

class exc_test
def div
x=0
raise a=b/x
rescue
puts "im rescued"

ensure

puts "I was not let go"
end

end

The "ensure" is like finally" in java,"raise" is like throw,and "rescue" is like catch.
If all rescues fail "ensure" will catch the exception..

You can also create other exceptions of your own which inherits from Exception class.

class Myownexception<Exception


end

e1=Myownexception.new
raise MyownException

rescue Myownexception=>w
puts "im caught by my rescuer"
end

raise 4/0
 rescue
puts "im rescued by zerodiverror"
end

Standard Library functions: 
         There are many inbuilt functions which are included together in a library which can be required and included and the methods can be used.Whenever you want specific methods check the ruby documentations and use it.

SCalars Date and TIme:
     Date can be identified using  Time class..The following example gives you a gist.

time = Time.new

# Components of a Time
puts "Current Time : " + time.inspect
puts time.year    # => Year of the date 
puts time.month   # => Month of the date (1 to 12)
puts time.day     # => Day of the date (1 to 31 )
puts time.wday    # => 0: Day of week: 0 is Sunday
puts time.yday    # => 365: Day of year
puts time.hour    # => 23: 24-hour clock
puts time.min     # => 59
puts time.sec     # => 59
puts time.usec    # => 999999: microseconds
puts time.zone    # => "UTC": timezone name

Instance_eval and class_eval: 

Instance_eval has 2 different uses

1)Setting and getting the instance variables.

object_name.instance_eval do

puts @geek

end

2)It is used to define class methods

classname.instance_eval do

def who

//class methods content

end

puts classname.who 

Class_eval:

1)setting and getting class variables

puts classname.class_eval("@geek")

classname.class_eval do

 @@geek="fds"

end

2)Defining instance methods

classname.class_eval do

//instance methods

end

Another method is used to set and get variables

object.instance_variable_get(geek)

object.instance_variable_set(geek="rona")

Few Other Ruby examples!:)

In case you have a function inside another function then when you call the uter function the inner function is defined.Again when you call the inner function it gets invoked.If both the inner and outer function has the same name,then all calls other than the first call points to the second inner function.


def one
    puts "one"
    def one
        puts "two"
    end
end

one
one
oneop:one two two two....

This is another function with define_method inside a "def" and allows dynamic multiplication..

class Mul
def self.fn(other)
    define_method "mul_#{other}" do
         puts 5*other
    end
end
end
val=3

m=Mul.new
Mul::fn(3)----------------------**
puts "before"
m.mul_3--------------------------*
puts "after"
op:
before
15
after

In the above example you would have noted that though it is dynamic you would hve to specify the changed value in * and **.To avoid this you create all instance of function from mul_1 to mul_10..Check the foll pgm ...

class Multiplier
  def self.fn(n)
    define_method "mul_#{n}" do |x|
    puts  x*n
  end
end
  
for i in (1..10)
fn(i)
end

end


m = Multiplier.new


 m.mul_3(5)----*
 m.mul_7(5)

Here in each case u need to call only once.
There is another important function "method_missing" that is called when undefined methods are called.You can override this method to perform  the requires task you want.Now we will override the method_missing function and perform the same above task.

class Check

def method_missing(name,*args)
    puts "im n missing method function"
    self.class.send(:define_method ,name) do |*args|
        puts "im inside define_method"
        #name1=name[name.length-1]
         name1=name.to_s
         
          name2=name1.split("_")
           value=name2[1]         
          return value.to_i*args[0]
          

    end

self.send(name,*args)
end

end

c1=Check.new
puts c1.mul_4(10)
puts c1.mul_4(6)
puts c1.mul_2(60)
In the above method we have a great advantage.You define only the function that is called.Not all the function as in the previous case.

Inject Function:
     puts   [1, 2, 3, 4].inject { |result,a|; result +a }
This returns the sum of the values of the array.

Defining and Using the attr-accessor:

class Animal
  

    define_method attr_name do
      instance_variable_get("@#{attr_name}")
    end
    
    define_method "#{attr_name}=" do |new_val|
      instance_variable_set("@#{attr_name}", new_val)
    end
    
  end
  my_attr_accessor :name
  my_attr_accessor :age
end

a = Animal.new
a.name = "Rona"
a.age=100
puts a.name
puts a.age


op.:
Rona
100


Code for sending mail using "gmail" in ruby:


require 'net/smtp'

YourDomain = 'smtp.gmail.com'
YourAccountName = 'from####@gmail.com'
YourPassword = '######'

FromAddress = 'from###@gmail.com'
ToAddress = 'to####@gmail.com'


@msg = "Subject: Hi There!\nThis is the body.  Tested on ruby 1.8.7"

smtp = Net::SMTP.new 'smtp.gmail.com', 587
smtp.enable_starttls
smtp.start(YourDomain, YourAccountName, YourPassword, :login) do
  smtp.send_message(@msg, FromAddress, ToAddress)
  puts 'Mail sent'
end

This code facilitates you to first login and authenticate your account and the n send your mail.You have to install the gem "tlsmail" for this to execute.

-->587 is the post number through which the connection will be established.

What is aliasing??How is it done??

   Alias_ method is used for aliasing functions.At a particular instant when alias_method function is encountered the new function points to the old function at that instant.For instance consider the example..

Syntax: alias_method :newfn :oldfn

You can 

class Alias_test

def alias1

    puts "This is the first function"

end

alias-method :alias_dup :alias1

def alias1

    puts "This is the second function"

end

end

Alias_test a1

a1.alias_dup

a1.alias1

Output:

This is first function

This is second function