rails 2.2.3 → 2.3.2

data/lib/rails/plugin/loader.rb

@@ -16,52 +16,91 @@ module Rails
       def initialize(initializer)
         @initializer = initializer
       end
-      
+
       # Returns the plugins to be loaded, in the order they should be loaded.
       def plugins
         @plugins ||= all_plugins.select { |plugin| should_load?(plugin) }.sort { |p1, p2| order_plugins(p1, p2) }
       end
 
+      # Returns the plugins that are in engine-form (have an app/ directory)
+      def engines
+        @engines ||= plugins.select(&:engine?)
+      end
+
       # Returns all the plugins that could be found by the current locators.
       def all_plugins
         @all_plugins ||= locate_plugins
         @all_plugins
       end
-    
+
       def load_plugins
-        plugins.each do |plugin| 
+        plugins.each do |plugin|
           plugin.load(initializer)
           register_plugin_as_loaded(plugin)
         end
+
+        configure_engines
+
         ensure_all_registered_plugins_are_loaded!
       end
-      
+
       # Adds the load paths for every plugin into the $LOAD_PATH. Plugin load paths are
       # added *after* the application's <tt>lib</tt> directory, to ensure that an application
       # can always override code within a plugin.
       #
-      # Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.  
+      # Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.
       def add_plugin_load_paths
         plugins.each do |plugin|
           plugin.load_paths.each do |path|
             $LOAD_PATH.insert(application_lib_index + 1, path)
-            ActiveSupport::Dependencies.load_paths      << path
-            unless Rails.configuration.reload_plugins?
+
+            ActiveSupport::Dependencies.load_paths << path
+
+            unless configuration.reload_plugins?
               ActiveSupport::Dependencies.load_once_paths << path
             end
           end
         end
+
         $LOAD_PATH.uniq!
-      end      
-      
+      end
+
+      def engine_metal_paths
+        engines.collect(&:metal_path)
+      end
+
       protected
-      
+        def configure_engines
+          if engines.any?
+            add_engine_routing_configurations
+            add_engine_controller_paths
+            add_engine_view_paths
+          end
+        end
+
+        def add_engine_routing_configurations
+          engines.select(&:routed?).collect(&:routing_file).each do |routing_file|
+            ActionController::Routing::Routes.add_configuration_file(routing_file)
+          end
+        end
+
+        def add_engine_controller_paths
+          ActionController::Routing.controller_paths += engines.collect(&:controller_path)
+        end
+
+        def add_engine_view_paths
+          # reverse it such that the last engine can overwrite view paths from the first, like with routes
+          paths = ActionView::PathSet.new(engines.collect(&:view_path).reverse)
+          ActionController::Base.view_paths.concat(paths)
+          ActionMailer::Base.view_paths.concat(paths) if configuration.frameworks.include?(:action_mailer)
+        end
+
         # The locate_plugins method uses each class in config.plugin_locators to
         # find the set of all plugins available to this Rails application.
         def locate_plugins
-          configuration.plugin_locators.map { |locator|
+          configuration.plugin_locators.map do |locator|
             locator.new(initializer).plugins
-          }.flatten
+          end.flatten
           # TODO: sorting based on config.plugins
         end
 
@@ -72,7 +111,7 @@ module Rails
         def configuration
           initializer.configuration
         end
-        
+
         def should_load?(plugin)
           # uses Plugin#name and Plugin#valid?
           enabled?(plugin) && plugin.valid?
@@ -86,21 +125,21 @@ module Rails
               plugin_a <=> plugin_b
             else
               effective_order_of(plugin_a) <=> effective_order_of(plugin_b)
-            end            
+            end
           end
         end
-        
+
         def effective_order_of(plugin)
           if explicitly_enabled?(plugin)
-            registered_plugin_names.index(plugin.name) 
+            registered_plugin_names.index(plugin.name)
           else
             registered_plugin_names.index('all')
-          end        
+          end
         end
 
         def application_lib_index
           $LOAD_PATH.index(File.join(RAILS_ROOT, 'lib')) || 0
-        end      
+        end
 
         def enabled?(plugin)
           !explicit_plugin_loading_order? || registered?(plugin)
@@ -121,32 +160,32 @@ module Rails
         def explicitly_registered?(plugin)
           explicit_plugin_loading_order? && registered_plugin_names.include?(plugin.name)
         end
-      
+
         def registered_plugins_names_plugin?(plugin)
           registered_plugin_names.include?(plugin.name) || registered_plugin_names.include?('all')
         end
-        
+
         # The plugins that have been explicitly listed with config.plugins. If this list is nil
-        # then it means the client does not care which plugins or in what order they are loaded, 
+        # then it means the client does not care which plugins or in what order they are loaded,
         # so we load all in alphabetical order. If it is an empty array, we load no plugins, if it is
         # non empty, we load the named plugins in the order specified.
         def registered_plugin_names
           configuration.plugins ? configuration.plugins.map(&:to_s) : nil
         end
-        
+
         def loaded?(plugin_name)
           initializer.loaded_plugins.detect { |plugin| plugin.name == plugin_name.to_s }
         end
-        
+
         def ensure_all_registered_plugins_are_loaded!
           if explicit_plugin_loading_order?
             if configuration.plugins.detect {|plugin| plugin != :all && !loaded?(plugin) }
-              missing_plugins = configuration.plugins - (plugins + [:all])
-              raise LoadError, "Could not locate the following plugins: #{missing_plugins.to_sentence}"
+              missing_plugins = configuration.plugins - (plugins.map{|p| p.name.to_sym} + [:all])
+              raise LoadError, "Could not locate the following plugins: #{missing_plugins.to_sentence(:locale => :en)}"
             end
           end
         end
-  
+
     end
   end
-end
+end

data/lib/rails/plugin/locator.rb

@@ -30,7 +30,7 @@ module Rails
     end
     
     # The Rails::Plugin::FileSystemLocator will try to locate plugins by examining the directories
-    # the the paths given in configuration.plugin_paths. Any plugins that can be found are returned
+    # in the paths given in configuration.plugin_paths. Any plugins that can be found are returned
     # in a list. 
     #
     # The criteria for a valid plugin in this case is found in Rails::Plugin#valid?, although

data/lib/rails/rack.rb

@@ -1,6 +1,8 @@
 module Rails
   module Rack
-    autoload :Logger, "rails/rack/logger"
+    autoload :Debugger, "rails/rack/debugger"
+    autoload :LogTailer, "rails/rack/log_tailer"
+    autoload :Metal, "rails/rack/metal"
     autoload :Static, "rails/rack/static"
   end
 end

data/lib/rails/rack/debugger.rb

@@ -0,0 +1,21 @@
+module Rails
+  module Rack
+    class Debugger
+      def initialize(app)
+        @app = app
+
+        require_library_or_gem 'ruby-debug'
+        ::Debugger.start
+        ::Debugger.settings[:autoeval] = true if ::Debugger.respond_to?(:settings)
+        puts "=> Debugger enabled"
+      rescue Exception
+        puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+        exit
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rails/rack/log_tailer.rb

@@ -0,0 +1,35 @@
+module Rails
+  module Rack
+    class LogTailer
+      EnvironmentLog = "#{File.expand_path(Rails.root)}/log/#{Rails.env}.log"
+
+      def initialize(app, log = nil)
+        @app = app
+
+        path = Pathname.new(log || EnvironmentLog).cleanpath
+        @cursor = ::File.size(path)
+        @last_checked = Time.now.to_f
+
+        @file = ::File.open(path, 'r')
+      end
+
+      def call(env)
+        response = @app.call(env)
+        tail_log
+        response
+      end
+
+      def tail_log
+        @file.seek @cursor
+
+        mod = @file.mtime.to_f
+        if mod > @last_checked
+          contents = @file.read
+          @last_checked = mod
+          @cursor += contents.size
+          $stdout.print contents
+        end
+      end
+    end
+  end
+end

data/lib/rails/rack/metal.rb

@@ -0,0 +1,51 @@
+require 'active_support/ordered_hash'
+
+module Rails
+  module Rack
+    class Metal
+      NotFoundResponse = [404, {}, []].freeze
+      NotFound = lambda { NotFoundResponse }
+
+      cattr_accessor :metal_paths
+      self.metal_paths = ["#{Rails.root}/app/metal"]
+      cattr_accessor :requested_metals
+
+      def self.metals
+        matcher = /#{Regexp.escape('/app/metal/')}(.*)\.rb\Z/
+        metal_glob = metal_paths.map{ |base| "#{base}/**/*.rb" }
+        all_metals = {}
+
+        metal_glob.each do |glob|
+          Dir[glob].sort.map do |file|
+            file = file.match(matcher)[1]
+            all_metals[file.camelize] = file
+          end
+        end
+
+        load_list = requested_metals || all_metals.keys
+
+        load_list.map do |requested_metal|
+          if metal = all_metals[requested_metal]
+            require metal
+            requested_metal.constantize
+          end
+        end.compact
+      end
+
+      def initialize(app)
+        @app = app
+        @metals = ActiveSupport::OrderedHash.new
+        self.class.metals.each { |app| @metals[app] = true }
+        freeze
+      end
+
+      def call(env)
+        @metals.keys.each do |app|
+          result = app.call(env)
+          return result unless result[0].to_i == 404
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rails/rack/static.rb

@@ -1,3 +1,5 @@
+require 'rack/utils'
+
 module Rails
   module Rack
     class Static
@@ -11,14 +13,18 @@ module Rails
       def call(env)
         path        = env['PATH_INFO'].chomp('/')
         method      = env['REQUEST_METHOD']
-        cached_path = (path.empty? ? 'index' : path) + ::ActionController::Base.page_cache_extension
 
         if FILE_METHODS.include?(method)
           if file_exist?(path)
             return @file_server.call(env)
-          elsif file_exist?(cached_path)
-            env['PATH_INFO'] = cached_path
-            return @file_server.call(env)
+          else
+            cached_path = directory_exist?(path) ? "#{path}/index" : path
+            cached_path += ::ActionController::Base.page_cache_extension
+
+            if file_exist?(cached_path)
+              env['PATH_INFO'] = cached_path
+              return @file_server.call(env)
+            end
           end
         end
 
@@ -30,6 +36,11 @@ module Rails
           full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
           File.file?(full_path) && File.readable?(full_path)
         end
+
+        def directory_exist?(path)
+          full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
+          File.directory?(full_path) && File.readable?(full_path)
+        end
     end
   end
 end

data/lib/rails/version.rb

@@ -1,8 +1,8 @@
 module Rails
   module VERSION #:nodoc:
     MAJOR = 2
-    MINOR = 2
-    TINY  = 3
+    MINOR = 3
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/rails_generator/base.rb

@@ -154,6 +154,9 @@ module Rails
         File.join(destination_root, relative_destination)
       end
 
+      def after_generate
+      end
+
       protected
         # Convenience method for generator subclasses to record a manifest.
         def record

data/lib/rails_generator/commands.rb

@@ -40,6 +40,7 @@ module Rails
         # Replay action manifest.  RewindBase subclass rewinds manifest.
         def invoke!
           manifest.replay(self)
+          after_generate
         end
 
         def dependency(generator_name, args, runtime_options = {})
@@ -181,15 +182,19 @@ HELP
             nesting = class_name.split('::')
             name = nesting.pop
 
+            # Hack to limit const_defined? to non-inherited on 1.9.
+            extra = []
+            extra << false unless Object.method(:const_defined?).arity == 1
+
             # Extract the last Module in the nesting.
             last = nesting.inject(Object) { |last, nest|
-              break unless last.const_defined?(nest)
+              break unless last.const_defined?(nest, *extra)
               last.const_get(nest)
             }
 
             # If the last Module exists, check whether the given
             # class exists and raise a collision if so.
-            if last and last.const_defined?(name.camelize)
+            if last and last.const_defined?(name.camelize, *extra)
               raise_class_collision(class_name)
             end
           end
@@ -293,7 +298,7 @@ HELP
           file(relative_source, relative_destination, template_options) do |file|
             # Evaluate any assignments in a temporary, throwaway binding.
             vars = template_options[:assigns] || {}
-            b = binding
+            b = template_options[:binding] || binding
             vars.each { |k,v| eval "#{k} = vars[:#{k}] || vars['#{k}']", b }
 
             # Render the source file with the temporary binding.

data/lib/rails_generator/generators/applications/app/app_generator.rb

@@ -1,184 +1,258 @@
 require 'rbconfig'
+require File.dirname(__FILE__) + '/template_runner'
 require 'digest/md5' 
 require 'active_support/secure_random'
 
 class AppGenerator < Rails::Generator::Base
-  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
-                              Config::CONFIG['ruby_install_name'])
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
 
-  DATABASES = %w(mysql oracle postgresql sqlite2 sqlite3 frontbase ibm_db)
+  DATABASES        = %w( mysql oracle postgresql sqlite2 sqlite3 frontbase ibm_db )
   DEFAULT_DATABASE = 'sqlite3'
 
-  default_options   :db => (ENV["RAILS_DEFAULT_DATABASE"] || DEFAULT_DATABASE),
-    :shebang => DEFAULT_SHEBANG, :freeze => false
   mandatory_options :source => "#{File.dirname(__FILE__)}/../../../../.."
+  default_options   :db => (ENV["RAILS_DEFAULT_DATABASE"] || DEFAULT_DATABASE),
+    :shebang => DEFAULT_SHEBANG, :with_dispatchers => false, :freeze => false
+
 
   def initialize(runtime_args, runtime_options = {})
     super
+
     usage if args.empty?
     usage("Databases supported for preconfiguration are: #{DATABASES.join(", ")}") if (options[:db] && !DATABASES.include?(options[:db]))
+
     @destination_root = args.shift
     @app_name = File.basename(File.expand_path(@destination_root))
   end
 
   def manifest
-    # Use /usr/bin/env if no special shebang was specified
-    script_options     = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
-    dispatcher_options = { :chmod => 0755, :shebang => options[:shebang] }
-
-    # duplicate CGI::Session#generate_unique_id
-    md5 = Digest::MD5.new
-    now = Time.now
-    md5 << now.to_s
-    md5 << String(now.usec)
-    md5 << String(rand(0))
-    md5 << String($$)
-    md5 << @app_name
-
-    # Do our best to generate a secure secret key for CookieStore
-    secret = ActiveSupport::SecureRandom.hex(64)
-
     record do |m|
-      # Root directory and all subdirectories.
+      create_directories(m)
+      create_root_files(m)
+      create_app_files(m)
+      create_config_files(m)
+      create_script_files(m)
+      create_test_files(m)
+      create_public_files(m)
+      create_documentation_file(m)
+      create_log_files(m)
+    end
+  end
+
+  def after_generate
+    if options[:template]
+      Rails::TemplateRunner.new(options[:template], @destination_root)
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} /path/to/your/app [options]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("-r", "--ruby=path", String,
+             "Path to the Ruby binary of your choice (otherwise scripts use env, dispatchers current path).",
+             "Default: #{DEFAULT_SHEBANG}") { |v| options[:shebang] = v }
+
+      opt.on("-d", "--database=name", String,
+            "Preconfigure for selected database (options: #{DATABASES.join('/')}).",
+            "Default: #{DEFAULT_DATABASE}") { |v| options[:db] = v }
+
+      opt.on("-D", "--with-dispatchers",
+            "Add CGI/FastCGI/mod_ruby dispatches code to generated application skeleton",
+            "Default: false") { |v| options[:with_dispatchers] = v }
+
+      opt.on("-f", "--freeze",
+            "Freeze Rails in vendor/rails from the gems generating the skeleton",
+            "Default: false") { |v| options[:freeze] = v }
+
+      opt.on("-m", "--template=path", String,
+            "Use an application template that lives at path (can be a filesystem path or URL).",
+            "Default: (none)") { |v| options[:template] = v }
+
+    end
+
+
+  private
+    def create_directories(m)
       m.directory ''
-      BASEDIRS.each { |path| m.directory path }
 
-      # Root
+      # Intermediate directories are automatically created so don't sweat their absence here.
+      %w(
+        app/controllers
+        app/helpers
+        app/models
+        app/views/layouts
+        config/environments
+        config/initializers
+        config/locales
+        db
+        doc
+        lib
+        lib/tasks
+        log
+        public/images
+        public/javascripts
+        public/stylesheets
+        script/performance
+        test/fixtures
+        test/functional
+        test/integration
+        test/performance
+        test/unit
+        vendor
+        vendor/plugins
+        tmp/sessions
+        tmp/sockets
+        tmp/cache
+        tmp/pids
+      ).each { |path| m.directory(path) }
+    end
+    
+    def create_root_files(m)
       m.file "fresh_rakefile", "Rakefile"
       m.file "README",         "README"
+    end
+    
+    def create_app_files(m)
+      m.file "helpers/application_controller.rb", "app/controllers/application_controller.rb"
+      m.file "helpers/application_helper.rb",     "app/helpers/application_helper.rb"
+    end
+
+    def create_config_files(m)
+      create_database_configuration_file(m)
+      create_routes_file(m)
+      create_locale_file(m)
+      create_initializer_files(m)
+      create_environment_files(m)
+    end
 
-      # Application
-      m.template "helpers/application.rb",        "app/controllers/application.rb", :assigns => { :app_name => @app_name, :app_secret => md5.hexdigest }
-      m.template "helpers/application_helper.rb", "app/helpers/application_helper.rb"
-      m.template "helpers/test_helper.rb",        "test/test_helper.rb"
-      m.template "helpers/performance_test.rb",   "test/performance/browsing_test.rb"
+    def create_documentation_file(m)
+      m.file "doc/README_FOR_APP", "doc/README_FOR_APP"
+    end
+
+    def create_log_files(m)
+      %w( server production development test ).each do |file|
+        m.file "configs/empty.log", "log/#{file}.log", :chmod => 0666
+      end
+    end    
 
-      # database.yml and routes.rb
+    def create_public_files(m)
+      create_dispatch_files(m)
+      create_error_files(m)
+      create_welcome_file(m)
+      create_browser_convention_files(m)
+      create_rails_image(m)
+      create_javascript_files(m)
+    end
+    
+    def create_script_files(m)
+      %w( 
+        about console dbconsole destroy generate runner server plugin
+        performance/benchmarker performance/profiler
+      ).each do |file|
+        m.file "bin/#{file}", "script/#{file}", { 
+          :chmod => 0755, 
+          :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang]
+        }
+      end
+    end
+
+    def create_test_files(m)
+      m.file "helpers/test_helper.rb",      "test/test_helper.rb"
+      m.file "helpers/performance_test.rb", "test/performance/browsing_test.rb"
+    end
+
+
+    def create_database_configuration_file(m)
       m.template "configs/databases/#{options[:db]}.yml", "config/database.yml", :assigns => {
         :app_name => @app_name,
-        :socket   => options[:db] == "mysql" ? mysql_socket_location : nil
-      }
-      m.template "configs/routes.rb", "config/routes.rb"
+        :socket   => options[:db] == "mysql" ? mysql_socket_location : nil }
+    end
+    
+    def create_routes_file(m)
+      m.file "configs/routes.rb", "config/routes.rb"
+    end
 
-      # Initializers
-      m.template "configs/initializers/inflections.rb", "config/initializers/inflections.rb"
-      m.template "configs/initializers/mime_types.rb", "config/initializers/mime_types.rb"
-      m.template "configs/initializers/new_rails_defaults.rb", "config/initializers/new_rails_defaults.rb"
+    def create_initializer_files(m)
+      %w( 
+        backtrace_silencers 
+        inflections 
+        mime_types 
+        new_rails_defaults
+      ).each do |initializer|
+        m.file "configs/initializers/#{initializer}.rb", "config/initializers/#{initializer}.rb"
+      end
 
-      # Locale
-      m.template "configs/locales/en.yml", "config/locales/en.yml"
+      m.template "configs/initializers/session_store.rb", "config/initializers/session_store.rb", 
+        :assigns => { :app_name => @app_name, :app_secret => ActiveSupport::SecureRandom.hex(64) }
+    end
 
-      # Environments
-      m.file "environments/boot.rb",    "config/boot.rb"
-      m.template "environments/environment.rb", "config/environment.rb", :assigns => { :freeze => options[:freeze], :app_name => @app_name, :app_secret => secret }
+    def create_locale_file(m)
+      m.file "configs/locales/en.yml", "config/locales/en.yml"
+    end
+
+    def create_environment_files(m)
+      m.template "environments/environment.rb", "config/environment.rb", 
+        :assigns => { :freeze => options[:freeze] }
+
+      m.file "environments/boot.rb",        "config/boot.rb"
       m.file "environments/production.rb",  "config/environments/production.rb"
       m.file "environments/development.rb", "config/environments/development.rb"
       m.file "environments/test.rb",        "config/environments/test.rb"
+    end
 
-      # Scripts
-      %w( about console dbconsole destroy generate performance/benchmarker performance/profiler performance/request process/reaper process/spawner process/inspector runner server plugin ).each do |file|
-        m.file "bin/#{file}", "script/#{file}", script_options
-      end
 
-      # Dispatches
-      m.file "dispatches/dispatch.rb",   "public/dispatch.rb", dispatcher_options
-      m.file "dispatches/dispatch.rb",   "public/dispatch.cgi", dispatcher_options
-      m.file "dispatches/dispatch.fcgi", "public/dispatch.fcgi", dispatcher_options
+    def create_dispatch_files(m)
+      if options[:with_dispatchers]
+        dispatcher_options = { :chmod => 0755, :shebang => options[:shebang] }
 
-      # HTML files
-      %w(404 422 500 index).each do |file|
-        m.template "html/#{file}.html", "public/#{file}.html"
+        m.file "dispatches/config.ru",     "config.ru"
+        m.file "dispatches/dispatch.rb",   "public/dispatch.rb",   dispatcher_options
+        m.file "dispatches/dispatch.rb",   "public/dispatch.cgi",  dispatcher_options
+        m.file "dispatches/dispatch.fcgi", "public/dispatch.fcgi", dispatcher_options
       end
+    end
 
-      m.template "html/favicon.ico",  "public/favicon.ico"
-      m.template "html/robots.txt",   "public/robots.txt"
-      m.file "html/images/rails.png", "public/images/rails.png"
-
-      # Javascripts
-      m.file "html/javascripts/prototype.js",    "public/javascripts/prototype.js"
-      m.file "html/javascripts/effects.js",      "public/javascripts/effects.js"
-      m.file "html/javascripts/dragdrop.js",     "public/javascripts/dragdrop.js"
-      m.file "html/javascripts/controls.js",     "public/javascripts/controls.js"
-      m.file "html/javascripts/application.js",  "public/javascripts/application.js"
-
-      # Docs
-      m.file "doc/README_FOR_APP", "doc/README_FOR_APP"
-
-      # Logs
-      %w(server production development test).each { |file|
-        m.file "configs/empty.log", "log/#{file}.log", :chmod => 0666
-      }
+    def create_error_files(m)
+      %w( 404 422 500  ).each do |file|
+        m.file "html/#{file}.html", "public/#{file}.html"
+      end
     end
-  end
 
-  protected
-    def banner
-      "Usage: #{$0} /path/to/your/app [options]"
+    def create_welcome_file(m)
+      m.file 'html/index.html', 'public/index.html'
     end
 
-    def add_options!(opt)
-      opt.separator ''
-      opt.separator 'Options:'
-      opt.on("-r", "--ruby=path", String,
-             "Path to the Ruby binary of your choice (otherwise scripts use env, dispatchers current path).",
-             "Default: #{DEFAULT_SHEBANG}") { |v| options[:shebang] = v }
+    def create_browser_convention_files(m)
+      m.file "html/favicon.ico", "public/favicon.ico"
+      m.file "html/robots.txt",  "public/robots.txt"
+    end
 
-      opt.on("-d", "--database=name", String,
-            "Preconfigure for selected database (options: #{DATABASES.join('/')}).",
-            "Default: #{DEFAULT_DATABASE}") { |v| options[:db] = v }
+    def create_rails_image(m)
+      m.file "html/images/rails.png", "public/images/rails.png"
+    end
 
-      opt.on("-f", "--freeze",
-            "Freeze Rails in vendor/rails from the gems generating the skeleton",
-            "Default: false") { |v| options[:freeze] = v }
+    def create_javascript_files(m)
+      %w( prototype effects dragdrop controls application ).each do |javascript|
+        m.file "html/javascripts/#{javascript}.js", "public/javascripts/#{javascript}.js"
+      end
     end
 
+
     def mysql_socket_location
-      MYSQL_SOCKET_LOCATIONS.find { |f| File.exist?(f) } unless RUBY_PLATFORM =~ /(:?mswin|mingw)/
-    end
-
-
-  # Installation skeleton.  Intermediate directories are automatically
-  # created so don't sweat their absence here.
-  BASEDIRS = %w(
-    app/controllers
-    app/helpers
-    app/models
-    app/views/layouts
-    config/environments
-    config/initializers
-    config/locales
-    db
-    doc
-    lib
-    lib/tasks
-    log
-    public/images
-    public/javascripts
-    public/stylesheets
-    script/performance
-    script/process
-    test/fixtures
-    test/functional
-    test/integration
-    test/performance
-    test/unit
-    vendor
-    vendor/plugins
-    tmp/sessions
-    tmp/sockets
-    tmp/cache
-    tmp/pids
-  )
-
-  MYSQL_SOCKET_LOCATIONS = [
-    "/tmp/mysql.sock",                        # default
-    "/var/run/mysqld/mysqld.sock",            # debian/gentoo
-    "/var/tmp/mysql.sock",                    # freebsd
-    "/var/lib/mysql/mysql.sock",              # fedora
-    "/opt/local/lib/mysql/mysql.sock",        # fedora
-    "/opt/local/var/run/mysqld/mysqld.sock",  # mac + darwinports + mysql
-    "/opt/local/var/run/mysql4/mysqld.sock",  # mac + darwinports + mysql4
-    "/opt/local/var/run/mysql5/mysqld.sock",  # mac + darwinports + mysql5
-    "/opt/lampp/var/mysql/mysql.sock"         # xampp for linux
-  ]
-end
+      [
+        "/tmp/mysql.sock",                        # default
+        "/var/run/mysqld/mysqld.sock",            # debian/gentoo
+        "/var/tmp/mysql.sock",                    # freebsd
+        "/var/lib/mysql/mysql.sock",              # fedora
+        "/opt/local/lib/mysql/mysql.sock",        # fedora
+        "/opt/local/var/run/mysqld/mysqld.sock",  # mac + darwinports + mysql
+        "/opt/local/var/run/mysql4/mysqld.sock",  # mac + darwinports + mysql4
+        "/opt/local/var/run/mysql5/mysqld.sock",  # mac + darwinports + mysql5
+        "/opt/lampp/var/mysql/mysql.sock"         # xampp for linux
+      ].find { |f| File.exist?(f) } unless RUBY_PLATFORM =~ /(:?mswin|mingw)/
+    end
+end