Ruby on Rails
What's Ruby
A programming language
Developed by Yukihiro Matsumoto (aka
Matz) in the 1990s
What's Rails
Initially developed by David Heinemeier
Hansson, out of his work on Basecamp, a
project management system
It is a framework of scripts in ruby that
provide for rapid development of web
applications, esp those with a database back
end
Rails can build the skeleton of an application,
including the database tables, in just a few
commands
Ruby
Syntax
Ruby is largely and loosely based on
perl (hence the name, according to
lore)
Completely object oriented
Some Important differences
Unlike PHP, scope in variables is
defined by the leading sigil
the $ sign denotes global scope, not a
variable
an @ represents local scope within an
object instance
@@ represents local scope within a class
A capitalized name is a constant
Historical Differences
Javascript--born of the competition between
two companies
PHP--created by a varied community
Ruby--the vision of a single person
Rails--the vision of another single person
When you compare these, you can see how
the starting point influences the process of
development
Playing on the Command Line
Ruby is an interpreter, just like php or bash:
Avatar:~ hays$ ruby
print "howdy world!"
^d
Or, use ruby -e "command":
ruby -e 'puts "hello\n"'
Or, you can just use irb, which is easier:
Avatar:~ hays$ irb
>> print "howdy world!"
howdy world!=> nil
>>
Object Oriented
Truly
Not a prototyping language like
javascript
Nor a procedural language with OOP
bolted on
Classes
A class is a kind of master object
Can contain constants and methods
Instances of object can be created from
a class, inheriting the traits of the class
A simple class
class Cat
end
(but this class doesn't do or mean
anything)
the class examples are derived from
http://www.juixe.com/techknow/index.php/2007/01/22/ruby-class-tutorial/
cat class
I want four attributes for a cat; name,
color, type, and attribute
class Cat # must be capitalized
attr_accessor :name, :type, :color, :attribute
def initialize(name, type, color, attribute)
@name = name
@type = type
@color = color
@attribute = attribute
end
creating a new cat
Now, I can create an instance of the cat
class:
gc = Cat.new("GC", "short hair",
"black", "gimpy")
lc = Cat.new("LC", "short hair",
"black", "little")
add a method
I'd like to be able to describe my cats
easily
So I add a method to the cat class:
def describe
@name + " is a " + @color + " "
+ @type + " who is "
+ @attribute + ".\n"
end
eliminating con-cat-ination
The concatenation is a bit awkward
Like php, ruby has a structure for
calling variables within a string:
"#{@name} is a #{@color} #{@type}
who is #{@attribute}.\n"
calling the method
If I call a cat with the describe method
attached, I can get the description of
that cat:
my_string= gc.describe
puts my_string
or:
puts gc.describe
finding cats by name
A second method, find_by_name:
def self.find_by_name(name)
found = nil
ObjectSpace.each_object(Cat) { |o|
found = o if o.name == name
}
found
end
Access Control
Methods in a class are public by default
Private methods are known only to the
individual object
Protected methods can only be called
by members of the class in which is was
defined
Variables
In ruby, vars are references to objects, not
objects themselves
So:
a = "my value"
b=a
a[0] = "n"
will change both a and b--but if you reassign
a, eg a="new value", a is linked to a new
object (this might bite you, but it's not likely)
Arrays
Create an array by assignment:
my_array = [ "one", "two", 3, 4 ]
Referencing the array:
puts "my_array[0] is:
#{my_array[0]}\n"
The brackets are methods of the array
class…
Hashes
What in php is called an associative array is called
a hash in ruby
Creating a hash by assignment:
my_hash = { 'tree' => 'pine', 'bird' => 'mocking'}
puts "\n"
puts "my_hash['tree'] is: #{my_hash['tree']}\n"
puts "my_hash['bird'] is: #{my_hash['bird']}\n"
Notice that the syntax is different
walking a hash or array
use the each method:
a=1
my_hash.each do |key, value|
puts "#{a} #{key} is: #{value}"
a = a +1
end
conditional
much like php and javascript, but
simpler syntax:
a=1
my_hash.each do |key, value|
if key == "tree"
puts "#{a} #{key} is: #{value}"
end
a = a +1
end
In summary
Ruby's syntax is pretty
Ruby is all about structure
Classes are easy to work with, if you're
new, start with simple examples
Rails
Model View Controller (MVC)
Layering again
MVC allows a project team to work on
different aspects of the application without
stepping on each other's toes quite so often
Note that neither PHP nor Javascript
encourage this, but it can be done in PHP
(not so much in Javascript)
Rails enforces MVC
Model
Contains the data of the application
Transient
Stored (eg Database)
Enforces "business" rules of the
application
Attributes
Work flow
Views
Provides the user interface
Dynamic content rendered through
templates
Three major types
Ruby code in erb (embedded ruby)
templates
xml.builder templates
rjs templates (for javascript, and thus ajax)
Controllers
Perform the bulk of the heavy lifting
Handles web requests
Maintains session state
Performs caching
Manages helper modules
Convention over Configuration
Notion that coding is reduced if we adopt a
standard way of doing things
Eg., if we have a class "Pet" in our model that
defines the characteristic of domestic animal,
in rails, the database table created for us will
be named "pets"
Other chunks of code look for each other by
their common names
Action Pack
Since views and controllers interact so tightly,
in rails they are combined in Action Pack
Action pack breaks a web request into view
components and controller compoents
So an action usually involves a controller
request to create, read, update, or delete
(CRUD) some part of the model, followed by
a view request to render a page
Processing URLs
The basic url used to access a controller is of
the form: http://server/controller/action
The controller will be one you generate, and
the action will be one you've defined in your
controller
So if you have a controller named "filer" and
that controller has an action named "upload",
the url will be something like
http://127.0.0.1/filer/upload
The View
The controller will have a folder in app/view
named after it, and in that will be the view
templates associated with the action methods
These templates are usually html with some
inserted ruby code
While code can be executed in these
templates, keep that simple--any data
controls should be made in the controller's
files
Creating a basic site
Three commands
rails demo
cd demo
ruby script/generate controller Bark
This creates the framework
Making it say something
A def in the
app/controller/bark_controller.rb file:
def hello
end
And some html in the app/views/bark
folder, hello.html.erb:
Howdy
Directory Structure
app: most of your code lives here
config: information environment and
database link
database.yml
development, test and production versions
doc, log, tmp
lib: your code, just a place to stick things that
don't have a good home elsewhere
Directory Structure
public: images, javascripts, stylesheets go
here
script: script that rails uses, most of these are
short and reference files in the lib dir for rails
vendor: 3rd party code
Generating a database site
Magic
rails temp
cd temp
rake db:create:all
ruby script/generate scaffold Person lname:string
fname:string email:string
rake db:migrate
ruby script/server
Sources
http://github.com/rails/rails/tree/master/actionpack
http://en.wikipedia.org/wiki/Ruby_on_Rails
http://www.whytheluckystiff.net/ruby/pickaxe/
http://www.pragprog.com/titles/rails3/agile-web-
development-with-rails-third-edition
http://www.juixe.com/techknow/index.php/2007/01
/22/ruby-class-tutorial/