class Team < ActiveRecord::Base
	validates_presence_of :name
end

Now if I try to make a team but don't type in a name, I get this:

Next, in Intype, I open teams_controller.rb and note that @team = Team.find(params[:id]) appears a number of times, namely in the Show, Edit, Update, and Destroy defs. To DRY that up (don't repeat yourself), I'll put that in a before filter. The top of my teams_controller.rb now looks like this:

class TeamsController  [:show, :edit, :update, :destroy]

  def index
    @teams = Team.all

    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @teams }
    end
  end

That says before Show, Edit, Update, or Destroy are run, run a method called find_team. That new method goes at the bottom of teams_controller.rb

  def destroy
    @team = Team.find(params[:id])
    @team.destroy

    respond_to do |format|
      format.html { redirect_to(teams_url) }
      format.xml  { head :ok }
    end
  end

private
  def find_team
    @team = Team.find(params[:id])
  end

end

Now if I ever need to change that code, I can change it in one place rather than four.

C:\Ruby186\tenthhole>ruby script/generate scaffold Team name:string
      exists  app/models/
      exists  app/controllers/
      exists  app/helpers/
      create  app/views/teams
      exists  app/views/layouts/
      exists  test/functional/
      exists  test/unit/
      create  test/unit/helpers/
      exists  public/stylesheets/
      create  app/views/teams/index.html.erb
      create  app/views/teams/show.html.erb
      create  app/views/teams/new.html.erb
      create  app/views/teams/edit.html.erb
      create  app/views/layouts/teams.html.erb
      create  public/stylesheets/scaffold.css
      create  app/controllers/teams_controller.rb
      create  test/functional/teams_controller_test.rb
      create  app/helpers/teams_helper.rb
      create  test/unit/helpers/teams_helper_test.rb
       route  map.resources :teams
  dependency  model
      exists    app/models/
      exists    test/unit/
      exists    test/fixtures/
      create    app/models/team.rb
      create    test/unit/team_test.rb
      create    test/fixtures/teams.yml
      create    db/migrate
      create    db/migrate/20100614005533_create_teams.rb

Generating a scaffold will create default code that, while not exactly what you want, will give you working code right off the bat. In addition to the models, views, and controllers it creates, it also creates a database migration file. To get my database up to date, I have to run the migration. From the command prompt:

C:\Ruby186\tenthhole>rake db:migrate
(in C:/Ruby186/tenthhole)
==  CreateTeams: migrating =========
-- create_table(:teams)
   -> 0.0010s
==  CreateTeams: migrated (0.0030s)

Let’s see where I am now. From the command prompt, I start the web server (ruby script/server) and point my browser to http://localhost:3000.

Not much there, but no errors. Now I can start adding teams by clicking on the New Team link.

No fancy names here, just numbers. And one ‘team’ that all available substitutes will belong to. That’s it for teams. I can add, delete, and edit the teams all with the code the scaffolding generator created.

C:\Ruby186>rails tenthhole
      create
      create  app/controllers
      create  app/helpers
      create  app/models
      create  app/views/layouts
      create  config/environments
      create  config/initializers
      create  config/locales
      create  db
      create  doc
      create  lib
      create  lib/tasks
      create  log
      create  public/images
      create  public/javascripts
      create  public/stylesheets
      create  script/performance
      create  test/fixtures
      create  test/functional
      create  test/integration
      create  test/performance
      create  test/unit
      create  vendor
      create  vendor/plugins
      create  tmp/sessions
      create  tmp/sockets
      create  tmp/cache
      create  tmp/pids
      create  Rakefile
      create  README
      create  app/controllers/application_controller.rb
      create  app/helpers/application_helper.rb
      create  config/database.yml
      create  config/routes.rb
      create  config/locales/en.yml
      create  db/seeds.rb
      create  config/initializers/backtrace_silencers.rb
      create  config/initializers/inflections.rb
      create  config/initializers/mime_types.rb
      create  config/initializers/new_rails_defaults.rb
      create  config/initializers/session_store.rb
      create  config/initializers/cookie_verification_secret.rb
      create  config/environment.rb
      create  config/boot.rb
      create  config/environments/production.rb
      create  config/environments/development.rb
      create  config/environments/test.rb
      create  script/about
      create  script/console
      create  script/dbconsole
      create  script/destroy
      create  script/generate
      create  script/runner
      create  script/server
      create  script/plugin
      create  script/performance/benchmarker
      create  script/performance/profiler
      create  test/test_helper.rb
      create  test/performance/browsing_test.rb
      create  public/404.html
      create  public/422.html
      create  public/500.html
      create  public/index.html
      create  public/favicon.ico
      create  public/robots.txt
      create  public/images/rails.png
      create  public/javascripts/prototype.js
      create  public/javascripts/effects.js
      create  public/javascripts/dragdrop.js
      create  public/javascripts/controls.js
      create  public/javascripts/application.js
      create  doc/README_FOR_APP
      create  log/server.log
      create  log/production.log
      create  log/development.log
      create  log/test.log

The syntax rails app_name tells rails to create the application with that name and set up all the directories and many of the files I will need. It puts them all in a directory with the apps name. With the basics of an app created, I’ll test it to make sure rails is working. I navigate to C:\Ruby186\tenthhole\ and type

C:\Ruby186\tenthhole>ruby script/server
=> Booting WEBrick
=> Rails 2.3.8 application starting on http://0.0.0.0:3000
=> Call with -d to detach
=> Ctrl-C to shutdown server
[2010-06-13 14:30:48] INFO  WEBrick 1.3.1
[2010-06-13 14:30:48] INFO  ruby 1.8.6 (2010-02-04) [i386-mingw32]
[2010-06-13 14:30:48] INFO  WEBrick::HTTPServer#start: pid=4984 port=3000
[2010-06-13 14:34:03] INFO  going to shutdown ...
[2010-06-13 14:34:03] INFO  WEBrick::HTTPServer#start done.

That starts the built-in web server that runs locally. In the third line from the bottom, I see that it’s using port 3000, so I open Firefox and navigate to http://localhost:3000 and see this:

That screen means rails installed correctly. Now I can start building my app. Back at the command line, I hit Control+C to exit the web server.

First, I went to RubyForge and downloaded and installed rubyinstaller-1.8.6-p398.exe. It created a directory at C:\Ruby186\.

I opened a DOS command window and navigated to that directory. Then I installed rails:

C:\Ruby186>gem install rails
Successfully installed rake-0.8.7
Successfully installed activesupport-2.3.8
Successfully installed activerecord-2.3.8
Successfully installed rack-1.1.0
Successfully installed actionpack-2.3.8
Successfully installed actionmailer-2.3.8
Successfully installed activeresource-2.3.8
Successfully installed rails-2.3.8
8 gems installed
Installing ri documentation for rake-0.8.7...
Installing ri documentation for activesupport-2.3.8...
Installing ri documentation for activerecord-2.3.8...
Installing ri documentation for rack-1.1.0...
Installing ri documentation for actionpack-2.3.8...
Installing ri documentation for actionmailer-2.3.8...
Installing ri documentation for activeresource-2.3.8...
Installing ri documentation for rails-2.3.8...
Installing RDoc documentation for rake-0.8.7...
Installing RDoc documentation for activesupport-2.3.8...
Installing RDoc documentation for activerecord-2.3.8...
Installing RDoc documentation for rack-1.1.0...
Installing RDoc documentation for actionpack-2.3.8...
Installing RDoc documentation for actionmailer-2.3.8...
Installing RDoc documentation for activeresource-2.3.8...
Installing RDoc documentation for rails-2.3.8...

Next I installed sqlite3

sqllite command line tool
sqllite dll

I unzipped them and put them in the C:\Ruby186\bin\ directory. Back to the command line, I typed:

C:\Ruby186>gem install sqlite3-ruby
Successfully installed sqlite3-ruby-1.3.0-x86-mingw32
1 gem installed
Installing ri documentation for sqlite3-ruby-1.3.0-x86-mingw32...

No definition for libversion

And that’s it. Ruby, rails, and sqllite3 are installed.

This creates some stuff, like an empty model named player.rb and, most notably, a database migration

Here’s the migration.

Then, I make the magic happen

This update MySQL, which now looks like this

Next post I’ll set up the scaffolding.

Here’s what it looks like in phpMyAdmin

After I hit create, I have a database with no tables in it

Next post, I’ll start creating models.

I’m going to create a rails app for a golf league. The league consists of ten two-man teams playing nine holes once per week. There are additional players that can sub for any team. There are two complicated calculations that I have to worry about. The first is handicap. The second is score.

Handicap is calculated as the average of the best x scores of the last y scores, where x and y are

1 of 2

2 of 3

3 of 4

3 of 5

If the player only as one score, 80% of that differential (from par) is the handicap.

Scoring goes like this: The lower handicap player (LH) from team A plays the lower handicap player from team B. There are 21 total points available per week. The LH paring plays 9 hole match play for 1 point per hole (9 points). The higher handicap (HH) paring plays 9 hole match play for 1 point per hole (9 points). Each pairing also plays adjusted stroke play (points 19 and 20). Then the two teams play adjusted stroke play on their combined score for the final point.

Here’s my preliminary try at models:

Teams
-name

Players
-name
-email

Courses
-name
-hole1par
-hole1handicap
-hole2par
-hole2handicap
…
-hole9handicap

Matches
-Date
-Course
-Team
-Player
-Hole
-Score

In Aptana, File > New

class AddLastAccessDate < ActiveRecord::Migration
  def self.up
    add_column :orders, :last_access, :datetime
  end

  def self.down
    remove_column :orders, :last_access
  end
end

Every time I change the cart, I need to update this field. In order.rb, I created a new private method

 def update_last_access
   self.last_access = DateTime.now
   self.save
 end

And I called that in both the add_product and remove_product methods. I made the method private, but I’m not sure I needed to.