rails 0.8.0

data/generators/new_mailer.rb

@@ -0,0 +1,119 @@
+#!/usr/local/bin/ruby
+
+require File.dirname(__FILE__) + '/../config/environments/production'
+
+def create_mailer_class(class_name, file_name, mail_actions)
+  File.open("app/models/" + file_name + ".rb", "w", 0777) do |mailer_file|
+    mailer_file.write <<EOF
+class #{class_name} < ActionMailer::Base
+#{mail_actions.collect { |action| 
+  "  def #{action}(sent_on = Time.now)\n" +
+  "    @recipients = ''\n" +
+  "    @from       = ''\n" +
+  "    @subject    = ''\n" +
+  "    @body       = { }\n" +
+  "    @sent_on    = sent_on\n" +
+  "  end" 
+}.join "\n\n" }
+end
+EOF
+  end
+end
+
+def create_templates(class_name, file_name, mail_actions)
+  Dir.mkdir("app/views/#{file_name}") rescue nil
+  mail_actions.each { |action| File.open("app/views/#{file_name}/#{action}.rhtml", "w", 0777) do |template_file|
+    template_file.write <<EOF
+#{class_name}##{action}
+EOF
+  end }
+end
+
+def create_fixtures(class_name, file_name, mail_actions)
+  Dir.mkdir("test/fixtures/" + file_name) rescue nil
+  mail_actions.each { |action| File.open("test/fixtures/#{file_name}/#{action}", "w", 0777) do |template_file|
+    template_file.write <<EOF
+#{class_name}##{action}
+EOF
+  end }
+end
+
+
+def create_test_class(class_name, file_name, mail_actions)
+  File.open("test/unit/" + file_name + "_test.rb", "w", 0777) do |test_file|
+    test_file.write <<EOF
+require File.dirname(__FILE__) + '/../test_helper'
+require '#{file_name}'
+
+class #{class_name}Test < Test::Unit::TestCase
+  def setup
+    @expected = TMail::Mail.new
+  end
+
+#{mail_actions.collect { |action| 
+  "  def test_#{action}\n" +
+  "    @expected.to      = ''\n" +
+  "    @expected.from    = ''\n" +
+  "    @expected.subject = ''\n" +
+  "    @expected.body    = read_notification_fixture \"#{action}\"\n" +
+  "    @expected.date    = Time.now\n" +
+  "    \n" +
+  "    actual = #{class_name}.create_#{action}(@expected.date)\n" +
+  "    \n" +
+  "    assert_equal @expected.encoded, actual.encoded\n" +
+  "  end" 
+}.join "\n\n" }
+
+  private
+    def read_notification_fixture(name)
+      IO.readlines(File.dirname(__FILE__) + "/../fixtures/#{file_name}/\#{name}").join
+    end
+end
+EOF
+  end
+end
+
+
+if !ARGV.empty?
+  mailer_name  = ARGV[0]
+  mail_actions = ARGV[1..-1]
+  
+  class_name = Inflector.camelize(mailer_name)
+  file_name  = Inflector.underscore(mailer_name)
+  
+  create_mailer_class(class_name, file_name, mail_actions)
+  create_templates(class_name, file_name, mail_actions)
+  create_fixtures(class_name, file_name, mail_actions)
+  create_test_class(class_name, file_name, mail_actions)
+else
+  puts <<-END_HELP
+
+NAME
+     new_mailer - create mailer and view stub files
+
+SYNOPSIS
+     new_mailer [mailer_name] [mail_actions ...]
+
+DESCRIPTION
+     The new_mailer generator takes the name of the new mailer class as the
+     first argument and a variable number of mail action names as subsequent arguments.
+     
+     From the passed arguments, new_mailer generates a class file in
+     app/models with a mail action for each of the mail action names passed.
+     It then creates a mail test suite in test/unit with one stub test case and one
+     stub fixture per mail action. Finally, it creates a template stub for each of the
+     mail action names in app/views under a directory with the same name as the class.
+     
+EXAMPLE
+     new_mailer Notifications signup forgot_password invoice
+     
+     This will generate a Notifications class in
+     app/models/notifications.rb, a NotificationsTest in
+     test/unit/notifications_test.rb, and signup, forgot_password, and invoice
+     in test/fixture/notification. It will also create signup.rhtml,
+     forgot_password.rhtml, and invoice.rhtml in app/views/notifications.
+     
+     The Notifications class will have the following methods: signup, forgot_password, 
+     and invoice.
+END_HELP
+end

data/generators/new_model.rb

@@ -0,0 +1,70 @@
+#!/usr/local/bin/ruby
+
+require File.dirname(__FILE__) + '/../config/environments/production'
+
+def create_model_class(model_name, file_name)
+  File.open("app/models/" + file_name  + ".rb", "w", 0777) do |model_file|
+    model_file.write <<EOF
+require 'active_record'
+
+class #{model_name} < ActiveRecord::Base
+end
+EOF
+  end
+end
+
+def create_test_class(model_name, file_name, table_name)
+    File.open("test/unit/" + file_name  + "_test.rb", "w", 0777) do |test_file|
+        test_file.write <<EOF
+require File.dirname(__FILE__) + '/../test_helper'
+require '#{file_name}'
+
+class #{model_name}Test < Test::Unit::TestCase
+  def setup
+    @#{table_name} = create_fixtures "#{table_name}"
+  end
+
+  def test_something
+    assert true, "Test implementation missing"
+  end
+end
+EOF
+    end
+end
+
+def create_fixtures_directory(table_name)
+  Dir.mkdir("test/fixtures/" + table_name) rescue puts "Fixtures directory already exists"
+end
+
+
+if !ARGV.empty?
+  model_name = ARGV.shift
+  file_name  = Inflector.underscore(model_name)
+  table_name = ARGV.shift || file_name
+
+  create_model_class(model_name, file_name)
+  create_test_class(model_name, file_name, table_name)
+  create_fixtures_directory(table_name)
+else
+  puts <<-HELP
+
+NAME
+     new_model - create model stub files
+
+SYNOPSIS
+     new_model [model_name]
+
+DESCRIPTION
+     The new_model generator takes the name of the new model and generates a model
+     file in app/models that decents from ActiveRecord::Base but is otherwise empty.
+     It then creates a model test suite in test/unit with one failing
+     test case. Finally, it creates fixture directory in test/fixtures.
+     
+EXAMPLE
+     new_model Account
+     
+     This will generate a Account class in app/models/account.rb, a AccountTest in 
+     test/unit/account_test.rb, and the directory test/fixtures/account.
+
+HELP
+end

data/helpers/abstract_application.rb

@@ -0,0 +1,8 @@
+require 'action_controller'
+require 'application_helper'
+
+# The filters added to this controller will be run for all controllers in the application.
+# Likewise will all the methods added be available for all controllers.
+class AbstractApplicationController < ActionController::Base
+  include ApplicationHelper
+end

data/helpers/application_helper.rb

@@ -0,0 +1,6 @@
+# The methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+  def self.append_features(controller) #:nodoc:
+    controller.ancestors.include?(ActionController::Base) ? controller.add_template_helper(self) : super
+  end
+end

data/helpers/test_helper.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/../config/environments/test"
+
+require 'test/unit'
+require 'active_record/fixtures'
+require 'action_controller/test_process'
+
+def create_fixtures(*table_names)
+  Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures", table_names)
+end

data/html/404.html

@@ -0,0 +1,6 @@
+<html>
+<body>
+  <h1>File not found</h1>
+  <p>Change this error message for pages not found in public/404.html</p>
+</body>
+</html>

data/html/500.html

@@ -0,0 +1,6 @@
+<html>
+<body>
+  <h1>Application error (Apache)</h1>
+  <p>Change this error message for exceptions thrown outside of an action (like in Dispatcher setups or broken Ruby code) in public/500.html</p>
+</body>
+</html>

data/html/index.html

@@ -0,0 +1 @@
+<html><head><META HTTP-EQUIV="Refresh" CONTENT="0;URL=_doc/index.html"></head></html>

data/lib/code_statistics.rb

@@ -0,0 +1,71 @@
+class CodeStatistics
+  def initialize(*pairs)
+    @pairs      = pairs
+    @statistics = calculate_statistics
+    @total      = calculate_total if pairs.length > 1
+  end
+
+  def to_s
+    print_header
+    @statistics.each{ |k, v| print_line(k, v) }
+    print_splitter
+  
+    if @total
+      print_line("Total", @total)
+      print_splitter
+    end
+  end
+
+  private
+    def calculate_statistics
+      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
+    end
+
+    def calculate_directory_statistics(directory, pattern = /.*rb/)
+      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+
+      Dir.foreach(directory) do |file_name| 
+        next unless file_name =~ pattern
+
+        f = File.open(directory + "/" + file_name)
+
+        while line = f.gets
+          stats["lines"]     += 1
+          stats["classes"]   += 1 if line =~ /class [A-Z]/
+          stats["methods"]   += 1 if line =~ /def [a-z]/
+          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
+        end
+      end
+
+      stats
+    end
+
+    def calculate_total
+      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+      total
+    end
+
+    def print_header
+      print_splitter
+      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
+      print_splitter
+    end
+
+    def print_splitter
+      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
+    end
+
+    def print_line(name, statistics)
+      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
+      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
+
+      puts "| #{name.ljust(20)} " +
+           "| #{statistics["lines"].to_s.rjust(5)} " +
+           "| #{statistics["codelines"].to_s.rjust(5)} " +
+           "| #{statistics["classes"].to_s.rjust(7)} " +
+           "| #{statistics["methods"].to_s.rjust(7)} " +
+           "| #{m_over_c.to_s.rjust(3)} " +
+           "| #{loc_over_m.to_s.rjust(5)} |"
+    end
+end

data/lib/dispatcher.rb

@@ -0,0 +1,46 @@
+#--
+# Copyright (c) 2004 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+class Dispatcher
+  DEFAULT_SESSION_OPTIONS = { "database_manager" => CGI::Session::PStore, "prefix" => "ruby_sess.", "session_path" => "/" }
+
+  def self.dispatch(cgi = CGI.new, session_options = DEFAULT_SESSION_OPTIONS, error_page = nil)
+    begin
+      request  = ActionController::CgiRequest.new(cgi, session_options)
+      response = ActionController::CgiResponse.new(cgi)
+
+      controller_name = request.parameters["controller"].gsub(/[^_a-zA-Z0-9]/, "").untaint
+
+      require "#{Inflector.underscore(controller_name)}_controller"
+      Object.const_get("#{Inflector.camelize(controller_name)}Controller").process(request, response).out
+    rescue Exception => e
+      begin
+        ActionController::Base.logger.info "\n\nException throw during dispatch: #{e.message}\n#{e.backtrace.join("\n")}"
+      rescue Exception
+        # Couldn't log error
+      end
+      
+      if error_page then cgi.out{ IO.readlines(error_page) } else raise e end
+    end
+  end
+end

data/lib/webrick_server.rb

@@ -0,0 +1,158 @@
+# Donated by Florian Gross
+
+require 'webrick'
+require 'cgi'
+require 'stringio'
+
+include WEBrick
+
+class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
+  def self.dispatch(options = {})
+    Socket.do_not_reverse_lookup = true # patch for OS X
+
+    server = WEBrick::HTTPServer.new(:Port => options[:port].to_i, :ServerType => options[:server_type], :BindAddress => options[:ip])
+    server.mount('/', DispatchServlet, options)
+
+    trap("INT") { server.shutdown }
+    server.start
+  end
+
+  def initialize(server, options)
+    @server_options = options
+    @file_handler = WEBrick::HTTPServlet::FileHandler.new(server, options[:server_root], {:FancyIndexing => true })
+    super
+  end
+
+  def do_GET(req, res)
+    unless handle_index(req, res)
+      unless handle_dispatch(req, res)
+        unless handle_file(req, res)
+          unless handle_mapped(req, res)
+            raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
+          end
+        end
+      end
+    end
+  end
+
+  alias :do_POST :do_GET
+
+  def handle_index(req, res)
+    if req.request_uri.path == "/"
+      if @server_options[:index_controller]
+        res.set_redirect WEBrick::HTTPStatus::MovedPermanently, "/#{@server_options[:index_controller]}/"
+      else
+        res.set_redirect WEBrick::HTTPStatus::MovedPermanently, "/_doc/index.html"
+      end
+
+      return true
+    else
+      return false
+    end
+  end
+
+  def handle_file(req, res)
+    begin
+      @file_handler.send(:do_GET, req, res)
+      return true
+    rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
+      res.set_error(err)
+      return true
+    rescue => err
+      p err
+      return false
+    end
+  end
+
+  def handle_mapped(req, res)
+    parsed_ok, controller, action, id = DispatchServlet.parse_uri(req.request_uri.path)
+    if parsed_ok
+      query = "controller=#{controller}&action=#{action}&id=#{id}"
+      query << "&#{req.request_uri.query}" if req.request_uri.query
+      origin = req.request_uri.path + "?" + query
+      req.request_uri.path = "/dispatch.rb"
+      req.request_uri.query = query
+      handle_dispatch(req, res, origin)
+    else
+      return false
+    end
+  end
+
+  def handle_dispatch(req, res, origin = nil)
+    return false unless /^\/dispatch\.(?:cgi|rb|fcgi)$/.match(req.request_uri.path)
+
+    env = req.meta_vars.clone
+    env["QUERY_STRING"] = req.request_uri.query
+    env["REQUEST_URI"] = origin if origin
+    
+    data = nil
+    if @server_options[:cache_classes]
+      old_stdin, old_stdout = $stdin, $stdout
+      $stdin, $stdout = StringIO.new(req.body || ""), StringIO.new
+
+      begin
+        require 'cgi'
+        CGI.send(:define_method, :env_table) { env }
+
+        load File.join(@server_options[:server_root], "dispatch.rb")
+
+        $stdout.rewind
+        data = $stdout.read
+      ensure
+        $stdin, $stdout = old_stdin, old_stdout
+      end
+    else
+      begin
+        require 'rbconfig'
+        ruby_interpreter = Config::CONFIG['ruby_install_name'] || 'ruby'
+      rescue Object
+        ruby_interpreter = 'ruby'
+      end
+      
+      dispatch_rb_path = File.expand_path(File.join(@server_options[:server_root], "dispatch.rb"))
+      IO.popen(ruby_interpreter, "r+") do |ruby|
+        ruby.puts <<-END
+          require 'cgi'
+          require 'stringio'
+          env = #{env.inspect}
+          CGI.send(:define_method, :env_table) { env }
+          $stdin = StringIO.new(#{(req.body || "").inspect})
+    
+          eval "load '#{dispatch_rb_path}'", binding, #{dispatch_rb_path.inspect}
+        END
+        ruby.close_write
+        data = ruby.read
+      end
+    end
+
+    raw_header, body = *data.split(/^[\xd\xa]+/on, 2)
+    header = WEBrick::HTTPUtils::parse_header(raw_header)
+    if /^(\d+)/ =~ header['status'][0]
+      res.status = $1.to_i
+      header.delete('status')
+    end
+    header.each { |key, val| res[key] = val.join(", ") }
+    
+    res.body = body
+    return true
+  rescue => err
+    p err, err.backtrace
+    return false
+  end
+  
+  def self.parse_uri(path)
+    component = /([-_a-zA-Z0-9]+)/
+
+    case path.sub(%r{^/(?:fcgi|mruby|cgi)/}, "/")
+      when %r{^/#{component}/?$} then
+        [true, $1, "index", nil]
+      when %r{^/#{component}/#{component}/?$} then
+        [true, $1, $2, nil]
+      when %r{^/#{component}/#{component}/#{component}/?$} then
+        [true, $1, $2, $3]
+      else
+        [false, nil, nil, nil]
+    end
+  end
+  
+end