manveru-ramaze 2009.04 → 2009.04.01

data/bin/ramaze

@@ -1,303 +1,80 @@
 #!/usr/bin/env ruby
 
-def include_ramaze
+begin
+  $:.unshift File.join(File.dirname(__FILE__), '../lib')
+  require 'ramaze'
+rescue LoadError
+  $:.shift
+
   begin
-    $:.unshift File.join(File.dirname(__FILE__), '/../lib')
-    require 'ramaze'
+    require 'rubygems'
   rescue LoadError
-    $:.shift
-
-    begin
-      require 'rubygems'
-    rescue LoadError
-    end
-    require 'ramaze'
   end
+  require 'ramaze'
 end
 
-def usage
-  txt = <<-TXT
-  Usage:
-
-    ramaze <start [PIDFILE]|stop [PIDFILE]|restart [PIDFILE]|status [PIDFILE]|create PROJECT|console> [ruby/rack options]
-
-    Commands:
-      * All commands which take an optional PIDFILE default to PROJECT.pid if you do not supply one.
-      * All commands which start a ramaze instance will default to webrick on port 7000 unless you supply
-        the rack options -p/--port PORT and/or * -s/--server SERVER.
-
-      start   - Starts an instance of this application.
-
-      stop    - Stops a running instance of this application.
-
-      restart - Stops running instance of this application, then starts it back up.  Pidfile
-                (if supplied) is used for both stop and start.
+additions = lambda do |op|
+  op.separator ''
+  op.separator 'Specialized options:'
 
-      status  - Gives status of a running ramaze instance
-
-      create  - Creates a new prototype Ramaze application in a directory named PROJECT in
-                the current directory.  ramaze create foo would make ./foo containing an
-                application prototype. Rack options are ignored here.
-
-      console - Starts an irb console with app.rb (and irb completion) loaded. This command
-                ignores rack options, ARGV is passed on to IRB.
-TXT
-  if is_windows?
-    txt << %x{ruby #{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
-  else
-    txt << %x{#{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
+  op.on('--create PROJECT', 'New application from proto') do |project_name|
+    require 'ramaze/tool/create'
+    Ramaze::Tool::Create.create(project_name)
+    exit
   end
-end
 
-## Methods for commands {{{
-def start
-  # Find the name of this app
-  app_name = default_pidfile.sub(/\.pid$/,'')
-  added_args = []
-  if daemonize = OURARGS.detect { |arg| arg.match(/^(-[dD]|--daemonize)$/) }
-    if pid_arg = OURARGS.detect { |arg| arg.match(/^(-P|--pid)/) }
-      puts "User supplied pid: #{pid_arg}"
-      pid_file = OURARGS[OURARGS.index(pid_arg) + 1]
-      puts "Starting daemon with user defined pidfile: #{pid_file}"
-    else
-      puts "Starting daemon with default pidfile: #{pid_file = default_pidfile}"
-      added_args += ["-P", pid_file]
-    end
-    if check_running?(pid_file)
-      $stderr.puts "Ramaze is already running with pidfile: #{pid_file}"
-      exit 127
-    end
-  end
-  added_args += ["-p", "7000"] unless OURARGS.detect { |arg| arg.match(/^(-p|--port)/) }
-  added_args += ["-s", "webrick"] unless OURARGS.detect { |arg| arg.match(/^(-s|--server)/) }
-  if is_windows?
-    exec("ruby", rackup_path.to_s, "config.ru", *(ARGV + added_args))
-  else
-    exec(rackup_path.to_s, "config.ru", *(ARGV + added_args))
+  op.on('-i', '--instant', "Start up with bare-bones Controller") do |instant|
+    require 'ramaze/controller/main'
   end
-end
-
-def create(command)
-  project_name = OURARGS[OURARGS.index(command) + 1]
-  if project_name.nil?
-    $stderr.puts "Must supply a project name" if project_name.nil?
-    puts usage
-    exit 1
-  end
-  opts = {}
-  if OURARGS.detect { |arg| arg.match(/^(--force)/) }
-    puts "Overwriting any existing files as requested."
-    opts[:force] = true
-  end
-  if OURARGS.detect { |arg| arg.match(/^(--amend)/) }
-    puts "Only amending missing files as requested."
-    opts[:amend] = true
-  end
-  include_ramaze
-  require 'ramaze/tool/create'
-  Ramaze::Tool::Create.create(project_name, opts)
-end
 
-def stop(command)
-  unless pid_file = find_pid(OURARGS[OURARGS.index(command) + 1])
-    $stderr.puts "No pid_file found!  Cannot stop ramaze (may not be started)."
-    return false
-  end
-  pid = File.read(pid_file).to_i
-  puts "Stopping pid #{pid}"
-  Process.kill("INT", pid)
-  sleep 2
-  if is_running?(pid)
-    $stderr.puts "Process #{pid} did not die, forcing it with -9"
-    Process.kill(9, pid)
-    File.unlink(pid_file) if File.file?(pid_file)
-    true
-  else
-    File.unlink(pid_file) if File.file?(pid_file)
-    true
-  end
-end
-
-def status(command)
-  unless pid_file = find_pid(OURARGS[OURARGS.index(command) + 1])
-    $stderr.puts "No pid_file found! Ramaze may not be started."
-    exit 1
-  end
-  puts "Pid file #{pid_file} found, PID is #{pid = File.read(pid_file)}"
-  unless is_running?(pid.to_i)
-    $stderr.puts "PID #{pid} is not running"
-    exit 1
-  end
-  if is_windows?
-    wmi = WIN32OLE.connect("winmgmts://")
-    processes, ours = wmi.ExecQuery("select * from win32_process where ProcessId = #{pid}"), []
-    processes.each { |p| ours << [p.Name, p.CommandLine, p.VirtualSize, p.CreationDate, p.ExecutablePath, p.Status ] }
-    puts "Ramaze is running!\n\tName: %s\n\tCommand Line: %s\n\tVirtual Size: %s\n\tStarted: %s\n\tExec Path: %s\n\tStatus: %s" % ours.first
-  else
-    require "pathname"
-    # Check for /proc
-    if File.directory?(proc_dir = Pathname.new("/proc"))
-      proc_dir = proc_dir.join(pid)
-      # If we have a "stat" file, we'll assume linux and get as much info
-      # as we can
-      if File.file?(stat_file = proc_dir.join("stat"))
-        stats = File.read(stat_file).split
-        puts "Ramaze is running!\n\tCommand Line: %s\n\tVirtual Size: %s\n\tStarted: %s\n\tExec Path: %s\n\tStatus: %s" % [
-          File.read(proc_dir.join("cmdline")).split("\000").join(" "),
-          "%s k" % (stats[22].to_f / 1024),
-          File.mtime(proc_dir),
-          File.readlink(proc_dir.join("exe")),
-          stats[2]
-        ]
-        exit
-      end
-    end
-    # Fallthrough status, just print a ps
-    puts "Ramaze process #{pid} is running!"
-    begin
-      puts %x{ps l #{pid}}
-    rescue
-      puts "No further information available"
-    end
+  op.on('-e', '--execute STRING', String, "Execute string instead of a start.rb.") do |execute|
+    eval execute
   end
 end
 
-## End Command methods }}}
+runner = ARGV.reverse.find{|arg| File.file?(arg) }
+runner ||= 'start.rb' if File.file?('start.rb')
 
-# Helper methods {{{
-def default_pidfile
-  return @default_pidfile if @default_pidfile
-  require "pathname"
-  @default_pidfile = (Pathname.new(".").expand_path.basename.to_s + ".pid").strip
-end
+if runner
+  overlay = {
+    :root => File.dirname(runner),
+    :runner => runner, :origin => :console,
+  }
 
-def is_windows?
-  return @is_win if @is_win
-  begin
-    require "win32ole"
-  rescue LoadError
+  [overlay, ENV, ARGV].each do |opt|
+    Ramaze::Global.merge!(opt, &additions)
   end
-  @is_win ||= Object.const_defined?("WIN32OLE")
-end
 
-def rackup_path
-  return @rackup_path if @rackup_path
-  # Use the supplied path if the user supplied -R
-  if path_supplied = ARGV.delete("-R")
-    @rackup_path = ARGV.delete(OURARGS[OURARGS.index("-R") + 1])
-    if @rackup_path and File.file?(@rackup_path)
-      return @rackup_path
-    else
-      $stderr.puts "rackup does not exist at #{@rackup_path} (given with -R)"
-    end
-  end
-  # Check with 'which' on platforms which support it
-  unless is_windows?
-    @rackup_path = %x{which rackup}.to_s.chomp
-    if @rackup_path.size > 0 and File.file?(@rackup_path)
-      return @rackup_path
-    end
-  end
-  # check for rackup in RUBYLIB
-  libs = ENV["RUBYLIB"].to_s.split(is_windows? ? ";" : ":")
-  if rack_lib = libs.detect { |r| r.match %r<(\\|/)rack\1> }
-    require "pathname"
-    @rackup_path = Pathname.new(rack_lib).parent.join("bin").join("rackup").expand_path
-    return @rackup_path if File.file?(@rackup_path)
-  end
-  begin
-    require "rubygems"
-    require "rack"
-    require "pathname"
-    @rackup_path = Pathname.new(Gem.bindir).join("rackup").to_s
-    return @rackup_path if File.file?(@rackup_path)
-  rescue LoadError
-    nil
-  end
-  @rackup_path = nil
-  raise "Cannot find path to rackup, please supply full path to rackup with -R"
-end
+  runner = File.expand_path(runner)
+  
+  console = Ramaze::Global.console
 
-def is_running?(pid)
-  if is_windows?
-    wmi = WIN32OLE.connect("winmgmts://")
-    processes, ours = wmi.ExecQuery("select * from win32_process where ProcessId = #{pid}"), []
-    processes.each { |process| ours << process.Name }
-    ours.first.nil?
-  else
-    begin
-      prio = Process.getpriority(Process::PRIO_PROCESS, pid)
-      true
-    rescue Errno::ESRCH
-      false
-    end
-  end
-end
+  if console
+    ARGV.clear #Avoid passing args to IRB
 
-def check_running?(pid_file)
-  return false unless File.file?(pid_file)
-  is_running?(File.read(pid_file).to_i)
-end
-
-def find_pid(pid_file)
-  if pid_file.nil? or not File.file?(pid_file)
-    pid_file = default_pidfile
-  end
-  unless File.file?(pid_file)
-    $stderr.puts "Could not find running process id."
-    return false
-  end
-  pid_file
-end
+    Ramaze.trait[:started] = true
+    require runner
 
-## End helper methods }}}
+    require 'irb'
+    require 'irb/completion'
 
-OURARGS = ARGV.dup
-command = ARGV.detect { |arg| arg.match(/^(?:--?)?(?:start|stop|restart|create|h(?:elp)?|v(?:ersion)?|console|status)/) }
-if command.nil?
-  command = ""
-else
-  ARGV.delete(command)
-end
+    ENV['IRBRC'] = ".irbrc" if File.exists? ".irbrc"
+    Ramaze.start! :run_loose => true
+    IRB.start
+    Ramaze.shutdown
+  end
+  
+  daemonize = Ramaze::Global.daemonize
 
-case command
-when /^(?:--?)?status$/
-  status(command)
-when /^(?:--?)?restart$/
-  stop(command)
-  start
-when /^(?:--?)?start$/
-  start
-when /^(?:--?)?create$/
-  create(command)
-when /^(?:--?)?stop$/
-  if stop(command)
-    puts "Ramazement has ended, go in peace."
-    $stdout.flush
+  unless daemonize.empty?
+    require 'ramaze/tool/daemonize'
+    Ramaze::daemonize(runner, daemonize)
   else
-    puts "Ramaze failed to stop (or was not running)"
+    Ramaze.trait[:started] = true
+    require runner
+    Ramaze.start!
   end
-when /^(?:--?)?console$/
-  require "ramaze"
-  require "irb"
-  require "irb/completion"
-  Ramaze.options.started = true
-  require "start"
-  IRB.start
-  puts "Ramazement has ended, go in peace."
-when /^(?:--?)?h(elp)?$/
-  puts usage
-when /^(?:--?)?v(ersion)?$/
-  include_ramaze
-  puts Ramaze::VERSION
-  exit
-when /^$/
-  puts "Must supply a valid command"
-  puts usage
-  exit 1
 else
-  puts "#{command} not implemented"
-  puts usage
-  exit 1
+  Ramaze::Global.merge!(ARGV, &additions)
+  puts Ramaze::Global.option_parser(&additions)
 end
-

data/doc/tutorial/todolist.html

@@ -3,7 +3,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-<meta name="generator" content="AsciiDoc 8.4.2" />
+<meta name="generator" content="AsciiDoc 8.4.1" />
 <title>The official Ramaze Todo-list tutorial</title>
 <style type="text/css">
 /* Debug borders */
@@ -448,12 +448,6 @@ either on the <a href="http://ramazetrac.purepistos.org/">Bug tracker</a>, or ju
 drop by on IRC on <tt>irc.freenode.org</tt> in the channel <tt>#ramaze</tt>.</p></div>
 <div class="paragraph"><p>If you have trouble with some of the terms used in this tutorial you can
 consult the <a href="#glossary">Glossary</a> at the end of this document.</p></div>
-<div class="paragraph"><p>We are also working on a book that describes Ramaze in more depth, called
-<em>Journey to Ramaze</em>, it is still very much work in progress, but some of the
-contents might interest you.</p></div>
-<div class="paragraph"><p>The repository for the book is at <a href="http://github.com/manveru/ramaze-book">http://github.com/manveru/ramaze-book</a>.
-Every once in a while, updates for the book will be available in HTML and PDF
-form at <a href="http://book.ramaze.net">http://book.ramaze.net</a>.</p></div>
 </div>
 <h2 id="_first_step_create">First Step, Create</h2>
 <div class="sectionbody">
@@ -527,7 +521,7 @@ Ramaze<span style="color: #990000">.</span>start</tt></pre></div></div>
 <pre><tt>delta ~/tmp/tutorial % ruby start.rb
 D [2009-03-30 14:15:01 $2124] DEBUG | : Using webrick
 I [2009-03-30 14:15:01 $2124]  INFO | : WEBrick 1.3.1
-I [2009-03-30 14:15:01 $2124]  INFO | : ruby 1.9.2 (2009-03-02) [i686-linux]
+I [2009-03-30 14:15:01 $2124]  INFO | : ruby 1.8.7 (2008-08-11) [i686-linux]
 D [2009-03-30 14:15:01 $2124] DEBUG | : TCPServer.new(0.0.0.0, 7000)
 D [2009-03-30 14:15:01 $2124] DEBUG | : Rack::Handler::WEBrick is mounted on /.
 I [2009-03-30 14:15:01 $2124]  INFO | : WEBrick::HTTPServer#start: pid=2124 port=7000</tt></pre>
@@ -558,7 +552,8 @@ you tremendously when it comes to writing your own applications.</p></div>
 This requires the <a href="http://rubyforge.org/projects/sqlite-ruby">sqlite-ruby</a>
 bindings.</p></div>
 <div class="paragraph"><p>You can try to <tt>gem install sqlite</tt>, which will complain if your system doesn&#8217;t
-provide bindings, in which case I have to refer you to <a href="http://sqlite.org">http://sqlite.org</a>.</p></div>
+provide bindings, in which case I have to refer you to
+TODO <a href="http://sqlite.rubyforge.org">http://sqlite.rubyforge.org</a></p></div>
 <div class="paragraph"><p>In order to use Sequel we also need a database connection.</p></div>
 <div class="paragraph"><p>So we create a new file at <em>model/init.rb</em> with following content:</p></div>
 <div class="listingblock">
@@ -568,11 +563,7 @@ http://www.lorenzobettini.it
 http://www.gnu.org/software/src-highlite -->
 <pre><tt><span style="font-weight: bold"><span style="color: #000080">require</span></span> <span style="color: #FF0000">'sequel'</span>
 
-Sequel<span style="color: #990000">::</span>Model<span style="color: #990000">.</span>plugin<span style="color: #990000">(:</span>schema<span style="color: #990000">)</span>
-
 DB <span style="color: #990000">=</span> Sequel<span style="color: #990000">.</span>sqlite<span style="color: #990000">(</span><span style="color: #FF0000">'todolist.db'</span><span style="color: #990000">)</span></tt></pre></div></div>
-<div class="paragraph"><p>The <tt>:schema</tt> plugin is required since Sequel 3.0, if you run a version prior
-to 2.12 you may remove this line if it gives you any problems.</p></div>
 <div class="paragraph"><p>Next we edit <em>start.rb</em>, remove the <tt>Hello</tt> class, and add a require for the
 file, <em>start.rb</em> should look like this now:</p></div>
 <div class="listingblock">
@@ -620,8 +611,6 @@ http://www.lorenzobettini.it
 http://www.gnu.org/software/src-highlite -->
 <pre><tt><span style="font-weight: bold"><span style="color: #000080">require</span></span> <span style="color: #FF0000">'sequel'</span>
 
-Sequel<span style="color: #990000">::</span>Model<span style="color: #990000">.</span>plugin<span style="color: #990000">(:</span>schema<span style="color: #990000">)</span>
-
 DB <span style="color: #990000">=</span> Sequel<span style="color: #990000">.</span>sqlite<span style="color: #990000">(</span><span style="color: #FF0000">'todolist.db'</span><span style="color: #990000">)</span>
 
 <span style="font-weight: bold"><span style="color: #000080">require</span></span> <span style="color: #FF0000">'model/task'</span></tt></pre></div></div>
@@ -1266,73 +1255,6 @@ http://www.gnu.org/software/src-highlite -->
 <div class="paragraph"><p>Voilà, you now have acquired the Certificate of Ramazeness and all your friends
 and enemies envy you.</p></div>
 </div>
-<h2 id="_twelfth_step_configuring_configurable_configurability">Twelfth Step, configuring configurable configurability</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>To round up this tutorial a bit, let&#8217;s introduce you to configuration in Ramaze.
-There are a number of ways to configure Ramaze, but here we&#8217;ll just see the
-most common ones with some options you&#8217;ll most likely want to change.</p></div>
-<div class="paragraph"><p>First of all, you have been running your ramaze application always on the same
-port, <tt>7000</tt>, which prevents you from starting more than one instance or other
-applications.</p></div>
-<div class="paragraph"><p>To change the port, you can, for example:</p></div>
-<div class="listingblock">
-<div class="content"><!-- Generator: GNU source-highlight 2.11.1
-by Lorenzo Bettini
-http://www.lorenzobettini.it
-http://www.gnu.org/software/src-highlite -->
-<pre><tt>Ramaze<span style="color: #990000">.</span>options<span style="color: #990000">.</span>adapter<span style="color: #990000">.</span>port <span style="color: #990000">=</span> <span style="color: #993399">80</span></tt></pre></div></div>
-<div class="admonitionblock">
-<table><tr>
-<td class="icon">
-<div class="title">Note</div>
-</td>
-<td class="content">Running a server on a port below 1024 will require root privileges and is
-      generally not advised for applications that don&#8217;t drop their privileges
-      after establishing a connection.
-      Please have a look at <a href="http://wiki.ramaze.net/Deployment">http://wiki.ramaze.net/Deployment</a> for better ways
-      to deploy your site using a reverse proxy like apache, lighttpd, or
-      nginx.</td>
-</tr></table>
-</div>
-<div class="paragraph"><p>OK, a different port is fine, but how about some speed-boost? For this we will
-need a faster server like <a href="http://mongrel.rubyforge.org">Mongrel</a> or
-<a href="http://thin.rubyforge.org">Thin</a>.</p></div>
-<div class="paragraph"><p>You can install either one via:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>gem install thin
-gem install mongrel</tt></pre>
-</div></div>
-<div class="paragraph"><p>Now to the configuration:</p></div>
-<div class="listingblock">
-<div class="content"><!-- Generator: GNU source-highlight 2.11.1
-by Lorenzo Bettini
-http://www.lorenzobettini.it
-http://www.gnu.org/software/src-highlite -->
-<pre><tt><span style="font-style: italic"><span style="color: #9A1900"># The default is WEBrick</span></span>
-Ramaze<span style="color: #990000">.</span>options<span style="color: #990000">.</span>adapter<span style="color: #990000">.</span>adapter <span style="color: #990000">=</span> <span style="color: #990000">:</span>webrick
-
-<span style="font-style: italic"><span style="color: #9A1900"># How about using Mongrel instead?</span></span>
-Ramaze<span style="color: #990000">.</span>options<span style="color: #990000">.</span>adapter<span style="color: #990000">.</span>adapter <span style="color: #990000">=</span> <span style="color: #990000">:</span>mongrel
-
-<span style="font-style: italic"><span style="color: #9A1900"># Or maybe Thin?</span></span>
-Ramaze<span style="color: #990000">.</span>options<span style="color: #990000">.</span>adapter<span style="color: #990000">.</span>adapter <span style="color: #990000">=</span> <span style="color: #990000">:</span>thin</tt></pre></div></div>
-<div class="paragraph"><p>For the full performance, switch Ramaze into <tt>:live</tt> mode:</p></div>
-<div class="listingblock">
-<div class="content"><!-- Generator: GNU source-highlight 2.11.1
-by Lorenzo Bettini
-http://www.lorenzobettini.it
-http://www.gnu.org/software/src-highlite -->
-<pre><tt><span style="font-style: italic"><span style="color: #9A1900"># The default is :dev</span></span>
-Ramaze<span style="color: #990000">.</span>options<span style="color: #990000">.</span>mode <span style="color: #990000">=</span> <span style="color: #990000">:</span>live
-
-<span style="font-style: italic"><span style="color: #9A1900"># And here comes :live</span></span>
-Ramaze<span style="color: #990000">.</span>options<span style="color: #990000">.</span>mode <span style="color: #990000">=</span> <span style="color: #990000">:</span>live</tt></pre></div></div>
-<div class="paragraph"><p>The major differences between <tt>:dev</tt> and <tt>:live</tt> are that in <tt>:live</tt> mode your
-code won&#8217;t be automatically reloaded if it has changed and we don&#8217;t run every
-request through <tt>Rack::Lint</tt>, which helps you to stay within the
-request/response specifications required by Rack.</p></div>
-</div>
 <h2 id="glossary">Glossary</h2>
 <div class="sectionbody">
 <div class="dlist glossary"><dl>
@@ -1408,7 +1330,7 @@ RSI
 <div id="footer">
 <div id="footer-text">
 Version 2.0<br />
-Last updated 2009-04-07 19:08:12 JST
+Last updated 2009-03-30 20:29:25 JST
 </div>
 </div>
 </body>

data/doc/tutorial/todolist.txt

@@ -32,15 +32,6 @@ drop by on IRC on `irc.freenode.org` in the channel `#ramaze`.
 If you have trouble with some of the terms used in this tutorial you can
 consult the <<glossary, Glossary>> at the end of this document.
 
-We are also working on a book that describes Ramaze in more depth, called
-'Journey to Ramaze', it is still very much work in progress, but some of the
-contents might interest you.
-
-The repository for the book is at http://github.com/manveru/ramaze-book.
-Every once in a while, updates for the book will be available in HTML and PDF
-form at http://book.ramaze.net.
-
-
 == First Step, Create
 
 The last version of this tutorial assumed a generator to produce a skeleton in
@@ -96,7 +87,7 @@ tradition, we create a file at the root of your application directory called
 require 'rubygems'
 require 'ramaze'
 
-class MainController < Ramaze::Controller
+class Hello < Ramaze::Controller
   def index
     "Hello, World!"
   end
@@ -111,7 +102,7 @@ Now we run it:
 delta ~/tmp/tutorial % ruby start.rb
 D [2009-03-30 14:15:01 $2124] DEBUG | : Using webrick
 I [2009-03-30 14:15:01 $2124]  INFO | : WEBrick 1.3.1
-I [2009-03-30 14:15:01 $2124]  INFO | : ruby 1.9.2 (2009-03-02) [i686-linux]
+I [2009-03-30 14:15:01 $2124]  INFO | : ruby 1.8.7 (2008-08-11) [i686-linux]
 D [2009-03-30 14:15:01 $2124] DEBUG | : TCPServer.new(0.0.0.0, 7000)
 D [2009-03-30 14:15:01 $2124] DEBUG | : Rack::Handler::WEBrick is mounted on /.
 I [2009-03-30 14:15:01 $2124]  INFO | : WEBrick::HTTPServer#start: pid=2124 port=7000
@@ -150,7 +141,8 @@ This requires the http://rubyforge.org/projects/sqlite-ruby[sqlite-ruby]
 bindings.
 
 You can try to `gem install sqlite`, which will complain if your system doesn't
-provide bindings, in which case I have to refer you to http://sqlite.org.
+provide bindings, in which case I have to refer you to
+TODO http://sqlite.rubyforge.org
 
 In order to use Sequel we also need a database connection.
 
@@ -160,14 +152,9 @@ So we create a new file at 'model/init.rb' with following content:
 --------------------------------------------------------------------------------
 require 'sequel'
 
-Sequel::Model.plugin(:schema)
-
 DB = Sequel.sqlite('todolist.db')
 --------------------------------------------------------------------------------
 
-The `:schema` plugin is required since Sequel 3.0, if you run a version prior
-to 2.12 you may remove this line if it gives you any problems.
-
 Next we edit 'start.rb', remove the `Hello` class, and add a require for the
 file, 'start.rb' should look like this now:
 
@@ -215,8 +202,6 @@ Finally, add a line to your 'model/init.rb' that requires 'model/task.rb':
 --------------------------------------------------------------------------------
 require 'sequel'
 
-Sequel::Model.plugin(:schema)
-
 DB = Sequel.sqlite('todolist.db')
 
 require 'model/task'
@@ -847,72 +832,35 @@ What we do cover is adding it to your application, or the `<head>` in
 Voilà, you now have acquired the Certificate of Ramazeness and all your friends
 and enemies envy you.
 
-
-== Twelfth Step, configuring configurable configurability
-
-To round up this tutorial a bit, let's introduce you to configuration in Ramaze.
-There are a number of ways to configure Ramaze, but here we'll just see the
-most common ones with some options you'll most likely want to change.
-
-First of all, you have been running your ramaze application always on the same
-port, `7000`, which prevents you from starting more than one instance or other
-applications.
-
-To change the port, you can, for example:
-
-[source,ruby]
---------------------------------------------------------------------------------
-Ramaze.options.adapter.port = 80
---------------------------------------------------------------------------------
-
-NOTE: Running a server on a port below 1024 will require root privileges and is
-      generally not advised for applications that don't drop their privileges
-      after establishing a connection.
-      Please have a look at http://wiki.ramaze.net/Deployment for better ways
-      to deploy your site using a reverse proxy like apache, lighttpd, or
-      nginx.
-
-OK, a different port is fine, but how about some speed-boost? For this we will
-need a faster server like http://mongrel.rubyforge.org[Mongrel] or
-http://thin.rubyforge.org[Thin].
-
-You can install either one via:
-
---------------------------------------------------------------------------------
-gem install thin
-gem install mongrel
---------------------------------------------------------------------------------
-
-Now to the configuration:
-
-[source,ruby]
---------------------------------------------------------------------------------
-# The default is WEBrick
-Ramaze.options.adapter.adapter = :webrick
-
-# How about using Mongrel instead?
-Ramaze.options.adapter.adapter = :mongrel
-
-# Or maybe Thin?
-Ramaze.options.adapter.adapter = :thin
---------------------------------------------------------------------------------
-
-For the full performance, switch Ramaze into `:live` mode:
-
-[source,ruby]
---------------------------------------------------------------------------------
-# The default is :dev
-Ramaze.options.mode = :live
-
-# And here comes :live
-Ramaze.options.mode = :live
---------------------------------------------------------------------------------
-
-The major differences between `:dev` and `:live` are that in `:live` mode your
-code won't be automatically reloaded if it has changed and we don't run every
-request through `Rack::Lint`, which helps you to stay within the
-request/response specifications required by Rack.
-
+////
+That's just some experimental stuff, uncomment and create an 'image' folder to
+use it.
+
+[graphviz,"image/relations.png","dot"]
+---------------------------------------------------------------------
+digraph relations {
+  "start.rb" -> "controller/task.rb";
+  "start.rb" -> "model/init.rb";
+  "model/init.rb" -> "model/task.rb";
+  "controller/task.rb" -> "layout/default.xhtml";
+  "controller/task.rb" -> "view/index.xhtml";
+  "controller/task.rb" -> "view/done.xhtml";
+  "layout/default.xhtml" -> "public/css/screen.css";
+
+  "Tasks Controller" -> "create action";
+  "Tasks Controller" -> "index action";
+  "Tasks Controller" -> "open action";
+  "Tasks Controller" -> "done action";
+  "Tasks Controller" -> "close action";
+  "Tasks Controller" -> "delete action";
+
+  "done action"  -> "Task.filter(:done => true)";
+  "index action" -> "Task.filter(:done => false)";
+}
+---------------------------------------------------------------------
+
+image:image/relations.png[Relations of parts of the application]
+////
 
 [[glossary]]
 == Glossary