This document provides an overview of the Ruby programming language and the Ruby on Rails web application framework. It discusses that Ruby was created in the 1990s and is object-oriented and interpreted like PHP and Bash. It also summarizes that Rails was initially developed to support rapid development of web applications and can generate the skeleton of an application. The document also provides examples of using Ruby classes and objects.

2.  A programming language
 Developed by Yukihiro Matsumoto (aka Matz) in
the 1990s

3.  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

5.  Ruby is largely and loosely based on perl (hence
the name, according to lore)
 Completely object oriented

6.  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

7.  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

8.  Ruby is an interpreter, just like php or bash:
Avatar:~ hays$ ruby
print "howdy world!"
^d
 Or, use ruby -e "command":
ruby -e 'puts "hellon"'
 Or, you can just use irb, which is easier:
Avatar:~ hays$ irb
>> print "howdy world!"
howdy world!=> nil
>>

9.  Truly
 Not a prototyping language like javascript
 Nor a procedural language with OOP bolted on

10.  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

11. 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/

12.  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

13.  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")

14.  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

15.  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"

16.  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

17.  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

18.  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

19.  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)

20.  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…

21.  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

22.  use the each method:
a = 1
my_hash.each do |key, value|
puts "#{a} #{key} is: #{value}"
a = a +1
end

23.  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

24.  Ruby's syntax is pretty
 Ruby is all about structure
 Classes are easy to work with, if you're new, start
with simple examples

26.  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

27.  Contains the data of the application
◦ Transient
◦ Stored (eg Database)
 Enforces "business" rules of the application
◦ Attributes
◦ Work flow

28.  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)

29.  Perform the bulk of the heavy lifting
 Handles web requests
 Maintains session state
 Performs caching
 Manages helper modules

30.  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

31.  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

32.  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

33.  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

34.  Three commands
rails demo
cd demo
ruby script/generate controller Bark
 This creates the framework

35.  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:
<html><head></head>
<body>
<h3>Howdy</h3>
</body>
</html>

36.  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

37.  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

38.  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