This chapter is about inheritance, modules and mixins.

To make a subclass:

class Child < Parent
end

You can invoke parent class methods with “super”, just like in Java. You will usually want to call “super” in the initialize method if you are inheriting.

On page 95, it would be nice if the “private” keyword was tabbed in a few spaces.

Modules provide namespaces and allow some reusability. But unlike packages in Java it seems like they are similar to Ruby classes with two differences:
1. They have the word “module” in front of the name instead of the word “class”
2. Methods defined in the module have the module name in front of them. So if a Trigonometry class had a method “sin(x)” tyou would see this:

class Trigonometry
    # This is a constant
    PI = 22/7
    def sin(x)
        # implementation
    end
    # other stuff
end

A module would do it like this:

module Trigonometry
    def Trigonometry.sin(x)
        # implementation
    end
    # other stuff
end

If you use a module constant, you need to specify the module name and use the double-colon operator:

y = Trigonometry.sin(Trigonometry::PI/2)

Modules cannot have instances, so I guess they are like static classes in Java.

Is there inheritance for modules? I may find out

A mixin is when you include a module in a class. Then you can call the module’s method from a class instance as if they were parent methods.

The book talks quite a bit about the Enumerable mixin. I guess all you have to do is provide an “each” method, and you get all the iteration methods in collections (Array and Hash).

At the end of the chapter, they recommend designing programs with composition (has-a) and delegation (uses-a) instead of inheritance (is-a). They seem to say that mixins are more of a composition technique than an inheritance technique.

2012-02-14_08.04.44
product has many reviews
There is a proxy for the data – it is a subclass of Array

@review = Review.new
@review.product = Product.find(params[:product_id])

What is there is no product with that ID?
The “find” method will raise an exception (actually params[:product_id] is nil)
How to make it more forgiving

if params[:product_id].present?
    @review.product = Product.find_by_id(params[:product_id])
end

the find_by_* methods (aka dynamic finders) are more forgiving
You could even get rid of if

How to hide the product pull down in the review form?
Hidden form field
In _form.html.erb for review:

<% if @review.product.present? %>
    <%= f.hidden_field :product_id %>
<% else %>
<div>
    <%= f.collection_select :product_id, Product.all, :id, :name %>
</div>
<% end %>

Why do we need an equal sign for if it’s a hidden field?

<%= f.hidden_field :product_id %>

It still needs to be emitted to the HTML
In Rails, we have 2 methods: present? and blank?
blank? is like nil?
if a string is “  “, that is not nil, but it is blank
present? is the opposite of blank?
Why have both? Just negate one of them.
!a.blank? is “not the Ruby way” according to Jeff

[1,2,4].map{ |n| n*2 } is just like [1,2,4].collect{ |n| n*2 }

Matz does not like minimal interface. Sometimes map will feel right, and sometimes collect will.

[1,3,5].each do |n|
    puts n
end

map is an iterator, like each

w = [1,3,5].map do |n|
    n * 2
end

map wants a return value from each iteration of the block

<% if @review.product.present? %>
could also be
<% if @review.product %>

show.html.erb for reviews has this at the top:

<%= notice %>

This method will emit what ever is in the :notice key in the redirect from your controller
This will only live long enough to be redirected
This is called a flash message in Rails
it is a hash
the “flash hash”
You could also set the notice just before the redirect_to

flash[:notice] = "Way to go!"

You could make it flash[:zebra]
and call

<%= flash[:zebra] %>

in the html.erb file

http is stateless, so each request has to provide all the information the next request needs
Putting the query string in the URL has been one way to keep information
User story:
as a user, I want to add several products into a shopping cart
Jeff does it:
Carts and Products
This is many to many
But many carts will want to have products
Make a join model in between
CartItem
Cart has_many :cartItems
cart_item belongs_to a single :cart
A product will have many cart items
a cart item will belong_to a product
cart_itme will have cart_id and product_id

rails generate model Cart name:string
rails generate model CartItem cart_id:integer product_id:integer quantity:integer
rake db:migrate

class Cart
    has_many :cart_items
end

class CartItem
    belongs_to :cart
    belongs_to :product
end

add has_many :cart_item to product
The file name is Pascal case. In code or console, you use underscores

Jeff says the modelling is the hard part of Rails
In the console, you can do this:

cart = Cart.new
cart.cart_items
item = CartItem.new

in console, this will reload items from database
cart.cart_items(true)
or: cart.cart_items.create :product => Product.last
cart.cart_items.build will make a new cart in memory only.
cart.cart_items.new does not exist on the proxy

Add item to a cart. How to add another item to same cart?
Use cookies
Session data
Each has a name and a value
name/value pair, like a hash in Ruby
Expiration is optional – session by default
cookie data lives in the browser
How to add cookies:

session[:name] = value

Each cookie is limited to 4K of data
Do not put an ActiveRecord object into a cookie
Cookies are stored on the client machine
deal with session hash in your controllers
It is defined in ApplicationController’s parent
session[:cart_id] = cart.id
The session data is encrypted
In the create method for Cart controller:

if session[:cart_id]
    cart = Cart.find(session[:cart_id])
else
    cart = Cart.create
end

Put the cart stuff in a partial that everything can see.
app/views/share/_cart.html.erb

<%= render 'shared/cart >

Instead of accessing session hash inside view, make a helper method
Use view helpers

Seed file
Pagination
Seed file will help you pull in test data

Vince did pagination

Checkout: cart becomes an order
Cart partial:

<%= button_to "Check out", orders_url %>

In routes:
resources for rders
Create an orders controller

def create
    # do stuff
    # now clear session data
    reset_session
    redirect_to products_url, :notice => "Thanks for your order"
end

Look at guides for sessions and cookies

2012-02-16_08.20.30
In grandma example, they used a form_tag, not a form_for since they did not use a model.
form_tag(“/ask”, :method => “get”) do
put form tags here

routes:
get ‘ask’ => ‘grandmas#ask’

What we started:

input = ""
output = ""
puts "Talk to grandma"
while input != "BYE"
    input gets.chomp
    puts "What?"
    if input == input.uppercase
        puts "No, not since #{rand(1930..1950)}"
    end
end

Jeff recommends irb or rails console

Two methods:
a.upcase will check if the string contained in a is uppercase
a.upcase! will change the string to uppercase

Some people used regular expressions

Now going back to the shopping cart.
New models: Order, OrderItem

reset_session will reset the whole session
how to just get rid of cart?

session[:cart_id] = nil

Cycle through the cart creating order items, and call order.save afterwards. Fewer transactions.

New app for users

rails g model Item name:string value:integer
rails g model User name:string email:string password:string

Do not store passwords as strings. We will go over that later.

You could put this in the seeds.rb:

Item.create :name => "Hockey Stick", :value => 100

etc, etc, etc,

rake db:seed

To wipe out existing items in database, you could add this at the top of seeds.rb
Item.destroy_all
He added users and items to routes with resources

rails g controller Items new create show
rails g controller users new create show

Signup is easy: Just add user to database
Signin and signout are session management
If they are in database, when they sign in just make a session cookie

We create a sessions controller, inherits from application controller

SessionsController
    def new
    end
    
    def create
    user = User.find_by_name(params[:name])
        if user.present?
            if user.password == params[:password]
                session[:user_id] = user.id
                redirect_to items_url, :notice => "hello"
            else
                redirect_to items_url, :notice => "Nope"
            end
        else
            redirect_to items_url, :notice => "Nope"
        end
    end
    
    def destroy
        # reset_session
        # Or
        session[:user_id] = nil
        redirect_to items_url
    end
end

There will also be a folder for sessions, with a new.html.erb
We use form_tag instead of form_for since we have no model

<%= form_tag "/sessions" %> (or sessions_url)
    <% label_tag :name  %> <%= text_field :name  %>
    <% label_tag :password  %> <%= text_field :password %>
    <% submit_tag 'Sign In', new_session_url %>
<% end %>

Now in app layout:
if session[:user_id].present?
Hello, User.find(session[:user_id]).name

In routes:
post “/logout” => ‘sessions#destroy’, :as => :logout
link_to “Sign Out”,
button_to will create a post

Make the password a password_field_tag
To do password confirmation:
add a text field in form: password_confirmation, which you can do even though we are in a form_for
Then in model for User:
validates :password, :confirmation => true

For password security:
add “bcrypt-ruby” to Gemfile, run “bundle install”
To user, add a column called “password_digest” as a string
add line “has_secure_password” to the model

rails g scaffold User name:string email:string favorite_color:string password_digest:string
rake db:migrate

If you make a mistake,

rake db:migrate rollback STEP=1

Put line “has_secure_password” into the model
For user form partial:
Remove the password digest field from the form
Put in password and password_confirmation

Create an account and sign in at the same time
In users controller in create

if @user.save
    session[:user_id] = @user.id
end

So how do people sign in? We don’t want them to know their digest
In console:

u = User.find_by_name("Joe")
u.authenticate("hockey")

That should work
It will encrypt the input, it will not decrypt the string in the database

2012-02-07_08.32.40
He went over SQL in Ruby/Rails
Team has many players, Player belongs to Team

User story:
As a user, I want to see a list of products I can buy
A product has a name, color, and price. A product belongs to a single brand.
Prices are always in exact dollar amounts (no cents).
As a user, I want to add a review to a product
A review has a rating from 1-5 and a brief description

new rails app
products and brands
products belong to brand, brand has many products
Generate scaffold for brand and product
go back to index after create

Go over the scaffold
To get the brand in the collection select
Go to the form partial for the product
Only change the number field, not the label field
brand_id is the foreign key

<%= f.collection_select :brand_id, Brand.all, :id, :name %>

:id is param for Brand.all, :name is the field in the brand. That is what will be displayed
You may not want to always do Brand.all. We will go over that later.
View should not decide what data to show.
Put a variable in the new method in the controller

Now listing the products, we still get the brand ID

Make the description for a form a text field, not string

f.collection_select :product_id, Product.all, :id, :name

For rating, we want a list of  to 5

f.select :rating, [1,2,3,4,5]

You should still add a validates method in the model
What if you want 1 to 100?
There is a way to do a range

:rating, (1..100).to_a

to_a converts it to an array
Make the description box smaller. Go to the form partial
:rows => 5

Gems:
You can have more than one version

gem install rails

You may see:

sudo gem install rails

That will install it with admin rights
With rvm: never use sudo
It will install latest by default
gem will handle dependencies
railties is the guts/engines of rails
You can call
gem sources
to see where it will look for gems

Vince’s app:
We could edit the Gemfile

gem 'gmaps4rails'

Then run

bundle install

Back to Jeff
How to get words to appear on pull-down
Numbers:

f.select:rating, (1..5).to_a

Or

f.select:rating, [1,2,3,4,5]

or

f.select :rating, {"Excellent" => 5, "Very Good" => 4, "Okay" => 3, "Not so good" => 2, "Bad" => 1}

To validate that the rating will be between 1 and 5
Jeff starts with the guides
Jeff used

validates :rating, :numericality => {  nly_integer => true }
validates :rating, :numericality => {  nly_integer => true, :greater_than_or_equal_to => 1, :less_than_or_equal_to => 5 }

Test in the Rails console

2012-02-09_08.25.05
To support 1 URL: pages/social
One way:

rails g controller pages social

rails new friendBC
cd friendBC

-> Memorize the routes for resources
in routes.rb
get “pages/social”
in app/controllers add a controller: PagesController < ApplicationController
add a method called “social”
add app/views/pages/social.html.erb
get an image, put it in

<% image_tag "logo.png" %>

in assets/global directory
Make the background grey
app/assets/stylesheets/application.css

How to get JSON data?
He put some stuff in his controller

require 'open-uri' and require 'json'
result = JSON.parse(open("Some URL").read)

Put result in view file
In hashes, symbols and strings are not interchangeable. Usually they are.
To get the image:
in the view:

<%= image_tag @first_result["video"]["thumbnailUrl"] =>
 <img src="@first_result["video"]["thumbnailUrl"]">

Now he is calling @result @channel
–
Now Jeff is going through it
Agile practices: single responsibility, clear intention, DRY
These are the top 3
Rails cries out to help you do those things
When you download someone else’s code, you may need to run “bundle install”
Jeff moved some of the HTML onto a partial
Then change the variable in partial to one called “channel”
Then in the view call

<% render 'ribbon', :channel => @Whatever %>

In the partial, do not use raw “a” and “img” tags

<% link_to "Video goes here", "http://www.youtube.com#{post["video]["hostId"]}" %>

Now add the image:

<% link_to image_tag(post["video]["thunmbnailUrl"], :size => "240x180"), "http://www.youtube.com#{post["video]["hostId"]}", :target => :blank %>

Now back in view, we call the render three times. What if we pull another channel, we will have to add another line.
So in controller, create an array

@channels = [@facebook, @twitter, @youtube]

In the view:

<% @channels.each do |channel_data| %>
    <%= render 'ribbon', :channel => channel_data %>
<% end %>

Now they do not need to be instance variables in the controller
We still have repetition

def get_json_for_source(source)
    return JSON.parse((open("https://")).read)
end

Then in other method:

facebook = get_json_for_source('FACEBOOK')

This is Ruby skillz

A good pattern to know:
An array of strings. You are transforming the array into another array.

@channels = ['a', 'b', 'c'].map do |source|
    get_json_for_source(source)
end

map is like each
Look it up
collect is another good one to look up.

@names = users.collect dp |user|
    user.name
end

Could be

@names = users.collect {|user| user.name}

We saw one-line blocks in scaffolds in index

respond_to do |format|
    format.json {render json: @brands}
end
format.json do
    render json: @brands
end

Look in the dev/tth/shop folder
—————————————————–
Now: git and github
Look up “git – the simple guide”

git init

makes a new repository

git clone /path/to

to checkout a repository
Workflow:
working dir has files, index to stage commits, the head is the last commit
adding and committing

git add <filename>
 git add *
 git commit -m "message"

Now it is in the head, but not remote

git push origin master

afterwards, you can just do git push
To add a branch

git remote add origin <server>
 git checkout -b feature_x
 git pull to update - that pulls down latest changes

to reset:

git fetch origin; git reset --hard origin/master

gitk – is a good GUI
Neal making live changes

git status

He is on master branch

git branch

git status now tells him he made a change

git add .
 git commit -am "updated the Readme"
 git push origin master

or just

git push

There is also heroku

git push heroku master

or

git push heroku

Heroku requires postgres

Neal makes a new app

rails new ca_boat_party

It would be nice to stop an existing rails server
You could also specify a port

rails s -p 4000

It is now live on our local machine

git init

go to github.com
make a new repository

ca_boat_party - same name as directory
 git add .
 git commit -am ""

No good

git remote add origin git@github.com:nealg223/ca_boat_party
 git push -u origin master

Now put it up to heroku

gem install heroku

ssh keys are a pain

heroku create ca-boat-party --stack cedar

They have different stacks. bamboo is the current stack, good for rails up to 3.0. For rails 3.1 use cedar
Now push it to heroku
Update the gem file Gemfile to add postgres

group :production do
     gem 'pg'
 end

Put sqlite3 in group :development
bundle install
now commit changes to git

git add
 git commit -am "changed Gemfile"
 git push

Now push to heroku

git push heroku master

another command: heroku open
assets, like images, there could be some problems
another command is heroku logs
or

  heroku run console

it’s like an irb for heroku

heroku run rake db:migrate

in file app/config/environments/production.rb

set config.assets.compile = true

You can go to gitref.org
————————————————————–
Working with Shop app:
Get the average of reviews for a product

p = Product.find(1)
 p.reviews

Calling product.reviews: It gets rows from our table. It looks like an array, and behave like an array, but it can do more than what an array can do. It returns a proxy class. It is a proxy for the data you want.
So you can say p.reviews.count – it makes an SQL statement
You can do a lot of array stuff: p.reviews.first, p.reviews.sum(“rating”)
Arrays do not have sum method, but ActiveRecord does have sum method
p.reviews.average(“rating”) it gives us a BigDecimal instance
p.reviews.average(“rating”).to_s

Another association concept
A brand has many products.
A product has many reviews.
A brand has many products throught its products.

class Brand < ActiveRecord::Base
     has_many :products
     has_many :reviews, :through => :products
 end

The lines must be in that order
Review does not have brand id, but product has brand id, and review has product ID
So you can just do Brand.reviews without looping
Users want to see average rating for brand
So in brand show page – put it there for each brand
So to brand index page:

<%= brand.name %>

Rating:

<%= brand.reviews.average(:rating) %>

For reviewing the product form, it would be great if it knew which product you were using
No params hash for /reviews/new
Put a placeholder in the route
Put it in URL via ?key=value
Now you have a params hash
In product/show.html.erb

<%= link_to "Review This Product", new_review_url(:product_id => @product.id) %>

So now you see ?product_id=1 in url for new form
so in controller, look at new action in review controller

def new
     @review = Review.new
     @review.product_id = params[:product_id]
     # or @review.product = Product.find(params[:product_id])
     respond_to
 end

so in reviews/new.html.erb
New review for

<%= @review.product.name %>

Next: Leave out the pull-down form. But get product ID
replace collection_select with a hidden field

I found some notes I took in 2004 at a lecture I attended on coupling. It may have been a lecture Dave Thomas gave at CJUG.

Decoupling your code:
coupling: you can change something, and something else changes too
Methods calling methods: hard to understand, hard to maintain, hard to re-use.

Symptoms: Minor change recompiles the whole system. Unit tests require every jar on the box. Things stop working when you change their context. Hard to partition project between subteams.

Treat code like spy cells: limit interactions, if one is broken all others are safe, enforced structure.

Some coupling is good. Some code must call other code. Make it deliberate.

Types of coupling: Static, dynamic, domain, temporal.

Static coupling:
Classes are staticly coupled if one needs another to compile.
Java has interfaces. Good to couple to something more abstract. Gang of Four says to program to interfaces.
Interfaces reduce coupling. Split intent from implementation, single point of abstraction. Interfaces != list of class’s methods.
Inheritance is also static coupling. What if parent class changes?
Different rules for inheritance. Java: easy to inherit, hard to delegate. Inheritance is okay for “is-a”, bad for “has-a” or “uses-a”. Business world – not many uses for “is-a”, more “has-a” and “uses-a”
How to delegate?

Dynamic coupling:
happens at run-time. method chaining: order.getCustomer().getAddress().getState()
coupling question: what can change? What can break? Those methods can change.
Start by asking what caller is doing. Express intent at point of call.
Large-scale coupling: Compiling is transitive: a -> b, b -> c, then a -> c
can be circular.
use observer pattern: can break circular chains. Linear chain: add a layer. Mediator class. Is that a GoF pattern?
Mediator: construction manager. You deal with manager, manager deals with subcontractors. manager negotiates between subcontractors.

Subsystems: Things that need to be coupled tend to cluster. make each a subsystem. Ex: java package. Put a facade on a package. Security: read facade, read-write facade, returned via factories.

Domain coupling:
Business rules in code. When rules change, code must change. Value can be parameterized. Behavior can be too. Use interpreter. Interpreter pattern. Define action codes (pick out verbs)
Activate: A
Upgrade: U
Ship: S
Referral: R

Add strings of action codes to database.
Action code: idea from cobol. Do a search. Book idea: Cobol Principles for Java
not GoF intprepter pattern. Give users a screen to link product and actions.

Temporal coupling:
Coupling in time: dependence on sequence of events. imposing a sequence where none is needed.
Recommended: first edition of Bertrand Nayer’s book
Invariant: something that must be true. Invariant must be true at all times.
Design for concurrency. Do stuff in parallel. use a state machine. Can use mediator pattern. Threads: hard, okay with hash maps. Processed-based: RMI, SOAP. Message-based: JMS

Static coupling: reduce with interfaces, facade, delegation
Dynamic coupling: reduce with mediator, command pattern, express intent at point of call
Domain coupling: reduce with metadata, interpreter
Temporal coupling: reduce with monitor and maintain class invariants, synchronize correct places, parallelism

I only seem to have notes for the second day of week 4.

2012-02-02 Notes

Scaffolding notes:
respond_to
partials: Like a server side include

Look up respond_to method

respond_to do |format|
     format.html
     format.json { render json: @runners }
 end

JSON only:

respond_to do |format|
     format.json { render json: @runners }
 end

You could use curl as well.

514  curl -v "http://localhost:3000/runners"
 515  curl -v "http://localhost:3000/runners.json"
 516  curl -v "http://localhost:3000/runners" -H "Accept: text/html"
 518  curl -v "http://localhost:3000/runners" -H "Accept: application/json"

Try getting a png:

ca-imac1-2: ~/dev/tth/MarathonApp$ curl -v "http://localhost:3000/runners" -H "Accept: image/png"
 * About to connect() to localhost port 3000 (#0)
 *   Trying 127.0.0.1... connected
 * Connected to localhost (127.0.0.1) port 3000 (#0)
 > GET /runners HTTP/1.1
 > User-Agent: curl/7.21.4 (universal-apple-darwin11.0) libcurl/7.21.4 OpenSSL/0.9.8r zlib/1.2.5
 > Host: localhost:3000
 > Accept: image/png
 >
 < HTTP/1.1 406 Not Acceptable
 < Content-Type: image/png; charset=utf-8
 < X-Ua-Compatible: IE=Edge
 < Cache-Control: no-cache
 < X-Request-Id: 0e74fdad7575b392561230a70fb0cadd
 < X-Runtime: 0.001522
 < Content-Length: 1
 < Server: WEBrick/1.3.1 (Ruby/1.9.3/2011-10-30)
 < Date: Thu, 02 Feb 2012 14:42:53 GMT
 < Connection: Keep-Alive
 <
 * Connection #0 to host localhost left intact
 * Closing connection #0

I did not know there was a code 406.

There is a method called responds_with :html, :json, ml
Not used too often.  That was intended for all actions, but people did not want universal responders.

Scaffold does not provide any security out of the box.

New action also has a block to send json back
526  curl -v “http://localhost:3000/runners/new.json” -H “Accept: application/json”
returns

{"created_at":null,"id":null,"name":null,"updated_at":null}

This could help other developers know what data fields your classes have

The create action has an if block in the respond_to call to handle both a successful and unsuccessful creation.

In Ruby 1.9, you can use a new syntax for hashes

h = {:color => “Blue”, “fruit” => “apple”}

You could also do it like JSON

i = {color: “Blue”, “fruit” => “apple”}

You can only use the colon for keys if your key is a symbol.
So if you mix key types like in hash i, things get a bit ocnfusing. Your value can be a symbol, but that colon must still be on the left.

Assigment: look at the destroy. What is head :no_content about?

Memorize the RESTful Design chart with the routes, URLs, actions, etc

Let’s look at new and edit
TextMate tip: could go to the drawer. There is another way to get there. Command-T pops up a window, type in the name of your file. You can type something in the middle.
Look at the “new.html.erb” page. Where is the form?
Look at the “edit.html.erb” page. Where is the form?
We see this in each file:

<%= render 'form' %>

There is a file app/views/runners/_form.html.erb
Partials begin with underscores.
You just use the render method.
You can use instance variables in the partial.

From index.html, you could take this and put it in a partial:

<% @runners.each do |runner| %>
     <tr>
     <td><%= runner.name %></td>
     <td><%= link_to 'Show', runner %></td>
     <td><%= link_to 'Edit', edit_runner_path(runner) %></td>
     <td><%= link_to 'Destroy', runner, confirm: 'Are you sure?', method: :delete %></td>
     </tr>
 <% end %>

into a file called _list_of_runners.html.erb
and replace it with

<% render ‘list_of_runners’ %>

It makes the index.html clearer, but clutters up the directory.

Back to associations:
One-to-Many
One movie has many actors:

class Movie < ActiveRecord::Base
     has_many :actors
 end

class Actor < ActiveRecord::Base
     belongs_to :movie
 end

User stories:
As a user, I want to see the list of teams in our softball league.
A team has a company name and a nickname.
As a user, I want to select a team, and see the list of players on the team.
A player has a name and a jersey number.

What about many-to-many?
Actors are in many movies, and movies have many actors.
There is the notion of a “Role” in between Movie and Actor. That joins them together.
Movie <-> Role <-> Actor
Movie has many roles, and an Actor can have many roles
Roles would have id, movie_id and actor_id

class Actor < ActiveRecord::Base
     has_many :roles
 end

class Role < ActiveRecord::Base

    belongs_to :movie

    belongs_to :actor
end

User <-> Review <-> Landmark

You just generate a model for a role
rails g scaffold Movie title:string year:integer
rails g scaffold Actor name:string
rails g model role movie_id: integer actor_id:integer character:string
Add the has_many and belongs_to statements

IN the console:
the hard way

Role.create :movie_id => 1, :actor_id => 1, :character_name =>’Lucky Day’
 amigos.roles
 r = amigos.roles.first
 r.movie
 r.actor
 r.actor.name

Another way to create a role

amigos.roles
 amigos.roles.create :actor_id => 2, :character => ‘Dusty Bottoms’
 mark = Actor.create :name => ‘Mark Hamill’
 star_wars.roles.create :actor => mark
 starwars.roles.create :actor => Actor.find_by_id(3), :name => “Leia”

Some stuff on migrations and controller filters
What about the salary for the role?
You cannot put it in the old migration file and re-run that
The timestamps are on there for a reason

You need to create a new migration for the new field
rails generate migration $NAME $FIELD:$TYPE
rails generate migration AddSalaryToRole salary:integer
It might generate the right thing. You would need this:

def change
     add_column :roles, :salary, :integer
 end

Then type rake db:migrate to make changes
rake db:version

Controller filters:
In the controller, we do

@movie Movie.find(params[:id])

quite a few times. (This would be better for something that is multiple lines.)
Make a method
def find_the_movie
It might generate the right thing.
end
You can call that when you need to
But there is still some repetition
If you want to call a method at the beginning of an action or method, that is a before filter
Put this at the top:

before_filter :find_the_movie

So even though destroy action has @movie in the first line, you won’t get an error since you get @movie from the filter
But index method does not get params[:id]. You will get an error
So how to run it only for certain actions

before_filter :find_the_movie,  nly => [:show, :edit, :update, :destroy]

or to exclude some methods

before_filter :find_the_movie, :except => [:index, :new, :create]

DRY-ing code:
partials in views, pull them in with renders
controllers: use filters to extract common code

You can make your db lookups faster with indexes:

add_index :roles, :movie_id

You can put these in a migration
You probably want this for foreign keys

This chapter starts out with arrays (square brackets) and hashes (curly braces), which are important to know. It says that blocks when combined with collections are good iterators. The elements in arrays and hashes can be any type. Using different methods, arrays can be different data structures: sets, queues, dequeues, FIFO queues, instead of using different classes. In Ruby hashes, it keeps the objects in the order they were entered. Keep the names of the block parameters unique. You could use a colon, but I think it is better to keep them unique.

A block can be empty:

def three_times
    puts "in method three_times"
    yield
    yield
    yield
    puts "leaving three_times"
end

three_times { }
# { puts "Hello" }

But you must put in a block if a method has “yield” in it, even if yield has a parameter

To keep track of how many times you have gone through the loop, instead of each, use each_with_index. You will need a second variable for the block: index to track the count.

f = File.open("para.txt")
f.each_with_index do |line,index|
    puts "Line #{index} is: #{line}"
f.close

I did not quite get the “inject” method, and I skipped over some of the stuff about enumerators since it said I could.
Class methods start with the word “self” in front of them

At the end it gets into using blocks for closures and lambdas. Do we get into that with Rails? I think I get this stuff, but sometimes I have to look at it for a few minutes to get it. I don’t think I really know too well. Plus it appears there is another syntax for Ruby 1.9, which makes it more confusing.

There is an encouraging note at the end that if you don’t get it now, it’s okay. Thanks, Dave!

I really do not have too much to say right now about week 4. I really want to post something, even if it’s really short, just to stay consistent.

We learn about many-to-many associations this week.

This chapter was pretty easy. Mostly about objects and variables.

So what is an attribute? It seems like it is another name for an instance variable. They start with an “at” symbol. I am still not too clear what a symbol is.

I did not pay too much attention to the part on protected methods. I read somewhere that Bjarne Stroustrup, the creator of C++, at one point said the “protected” keyword was a mistake. Ever since then I have not paid much attention to protected.

Here are some notes on Chapter 2 of the Pickaxe book.

Single quoted strings take less processing, no interpolation
Return value of a method is the last statement, so you may not always want/need to put a “return” statement in there.
Local variables, method parameters and method names all start with lower case or underscore.
Global variables start with a dollar sign.
Instance variables start with an at symbol.
Class variables start with two at symbols.
Class names, module names and constants start with uppercase letter.
Character after @ may not be a digit
Multi-word instance variables get underscores between words, multiword class names get camel case.
Method names may end with ?, ! and =, although these have special meaning.

Arrays: like lists or arrays in Java, unlike primitive arrays you do not need to specify the size ahead of time.
Hashes: Like maps in Java.
The values do not need to be of the same type.
Shortcut for arrays:
a = ['ant', 'bee', 'cat', 'dog', 'elk']
same as
a = %w{ant bee cat dog elk}

Symbols: A lot of people in class had trouble with this concept. I am not too clear on it myself. They can be used as keys for hashes.
There is also a new Ruby 1.9 syntax for hashes.
Here is the old way:

inst_section = {
  :cello     = 'string',
  :clarinet  = 'woodwind',
  :violin    = 'string'
}

Now you can do this as well:

inst_section = {
  cello:    'string',
  clarinet: 'woodwind',
  violin:   'string'
}

This has caused some controversy on some Ruby mailing lists.
There are no braces for control structures. Instead Ruby uses the keyword “end”.
Next the book covers regular expressions. I am not going to get into details here. I have seen this before, although I know there is a lot to see.
Blocks are a bit weird to me. I will have to look them up somewhere. It seems to me like it is just another arg to a method. Is it special because it is code?
I altered some of the code from the book to make a method take a parameter as well as a block:

def call_block(arg)
  puts "Start of method"
  puts "arg is #{arg}"
  yield
  yield
  puts "End of method"
end

call_block('hello'){ puts "In the block" }
puts "About to call call_block with no block"
call_block('empty block'){}

The book says that blocks are used to implement iterators. I can never remember how to iterate through stuff. I will have to make a separate post about that.

cities = ['Chicago', 'Austin', 'Dallas' , 'Houston']
cities.each {|city| puts "The city is #{city}"}

3.upto()6 {|i| print i}
('a'..'e').each {|char| puts char}

The I/O section talks about printf. I thought the whole point of Ruby was not to deal with C?
puts prints to the terminal, gets gets from the terminal.
The command like arguments are in an array called ARGV.

James Spader is the baddest mo-fo evah!

I am a bit late, but here is my summary of week 3.

The lectures were rounding out MVC. We made a model class, a controller class, and some view pages. We then made the necessary methods, views and routes to list all the instances, show one instance, edit an instance, and delete an instance. I have been planning to sit down and whip up an MVC example. I just started it last night. I will do it again tonight.

Then Jeff said that we don’t really need to do that. You can just run the

rails generate scaffold blah blah blah

command. Neal pointed out that most people never learn the long way of doing it, they just learn the short way with scaffolding.  Not even the Hartl tutorial covers the detailed way, which kind of surprises me. The ironic thing is that on one day my pair partner is a guy who was taking a semester off from getting a computer science degree from Michigan State. When we had seen the “long” way of doing MVC in Rails, we were surprised at how easy it was compared to other frameworks.

I also saw my mentor. I wanted to do something with OAuth. I made some progress, but I hit a wall. I think the example that I was using was a bit out of date. Uncle Bob spoke. I got there late, but I was told that I saw the meat of the lecture.

I think I need to start getting more disciplined. I think that the “I have seen this before” phase may be ending for me. This is one of the reasons that I am going over the Pickaxe book. Another reason is that there was a shindig hosted by Braintree. Another student said she heard someone at the event who works at one of the local consulting firms saying that Code Academy should not teach just Rails, but more Ruby, since only learning Rails might not be giving people enough knowledge. This is a second-hand (or even third-hand) account of the event. But I guess there is some skepticism about Code Academy.

I also told another student that he looks like James Spader, and now he probably thinks I am a total jerk.

Image of James Spader taken in 2007, found on Wikipedia