rails 2.2.2 → 3.0.0

data/lib/performance_test_help.rb

@@ -1,5 +0,0 @@
-require 'action_controller/performance_test'
-
-ActionController::Base.perform_caching = true
-ActiveSupport::Dependencies.mechanism = :require
-Rails.logger.level = ActiveSupport::BufferedLogger::INFO

data/lib/rails/gem_builder.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'rubygems/installer'
-
-module Rails
-  
-  # this class hijacks the functionality of Gem::Installer by overloading its 
-  # initializer to only provide the information needed by 
-  # Gem::Installer#build_extensions (which happens to be what we have)
-  class GemBuilder < Gem::Installer
-
-    def initialize(spec, gem_dir)
-      @spec    = spec
-      @gem_dir = gem_dir
-    end
-
-    # silence the underlying builder
-    def say(message)
-    end
-
-  end
-end

data/lib/rails/gem_dependency.rb

@@ -1,251 +0,0 @@
-require 'rails/vendor_gem_source_index'
-
-module Gem
-  def self.source_index=(index)
-    @@source_index = index
-  end
-end
-
-module Rails
-  class GemDependency
-    attr_accessor :lib, :source
-
-    def self.unpacked_path
-      @unpacked_path ||= File.join(RAILS_ROOT, 'vendor', 'gems')
-    end
-
-    @@framework_gems = {}
-
-    def self.add_frozen_gem_path
-      @@paths_loaded ||= begin
-        source_index = Rails::VendorGemSourceIndex.new(Gem.source_index)
-        Gem.clear_paths
-        Gem.source_index = source_index
-        # loaded before us - we can't change them, so mark them
-        Gem.loaded_specs.each do |name, spec|
-          @@framework_gems[name] = spec
-        end
-        true
-      end
-    end
-
-    def framework_gem?
-      @@framework_gems.has_key?(name)
-    end
-
-    def vendor_rails?
-      Gem.loaded_specs.has_key?(name) && Gem.loaded_specs[name].loaded_from.empty?
-    end
-
-    def vendor_gem?
-      Gem.loaded_specs.has_key?(name) && Gem.loaded_specs[name].loaded_from.include?(self.class.unpacked_path)
-    end
-
-    def initialize(name, options = {})
-      require 'rubygems' unless Object.const_defined?(:Gem)
-
-      if options[:requirement]
-        req = options[:requirement]
-      elsif options[:version]
-        req = Gem::Requirement.create(options[:version])
-      else
-        req = Gem::Requirement.default
-      end
-
-      @dep = Gem::Dependency.new(name, req)
-      @lib      = options[:lib]
-      @source   = options[:source]
-      @loaded   = @frozen = @load_paths_added = false
-    end
-
-    def add_load_paths
-      self.class.add_frozen_gem_path
-      return if @loaded || @load_paths_added
-      if framework_gem?
-        @load_paths_added = @loaded = @frozen = true
-        return
-      end
-      gem @dep
-      @spec = Gem.loaded_specs[name]
-      @frozen = @spec.loaded_from.include?(self.class.unpacked_path) if @spec
-      @load_paths_added = true
-    rescue Gem::LoadError
-    end
-
-    def dependencies
-      return [] if framework_gem?
-      all_dependencies = specification.dependencies.map do |dependency|
-        GemDependency.new(dependency.name, :requirement => dependency.version_requirements)
-      end
-      all_dependencies += all_dependencies.map(&:dependencies).flatten
-      all_dependencies.uniq
-    end
-
-    def gem_dir(base_directory)
-      File.join(base_directory, specification.full_name)
-    end
-
-    def spec_filename(base_directory)
-      File.join(gem_dir(base_directory), '.specification')
-    end
-
-    def load
-      return if @loaded || @load_paths_added == false
-      require(@lib || name) unless @lib == false
-      @loaded = true
-    rescue LoadError
-      puts $!.to_s
-      $!.backtrace.each { |b| puts b }
-    end
-
-    def name
-      @dep.name.to_s
-    end
-
-    def requirement
-      r = @dep.version_requirements
-      (r == Gem::Requirement.default) ? nil : r
-    end
-
-    def frozen?
-      @frozen ||= vendor_rails? || vendor_gem?
-    end
-
-    def loaded?
-      @loaded ||= begin
-        if vendor_rails?
-          true
-        elsif specification.nil?
-          false
-        else
-          # check if the gem is loaded by inspecting $"
-          # specification.files lists all the files contained in the gem
-          gem_files = specification.files
-          # select only the files contained in require_paths - typically in bin and lib
-          require_paths_regexp = Regexp.new("^(#{specification.require_paths*'|'})/")
-          gem_lib_files = gem_files.select { |f| require_paths_regexp.match(f) }
-          # chop the leading directory off - a typical file might be in
-          # lib/gem_name/file_name.rb, but it will be 'require'd as gem_name/file_name.rb
-          gem_lib_files.map! { |f| f.split('/', 2)[1] }
-          # if any of the files from the above list appear in $", the gem is assumed to
-          # have been loaded
-          !(gem_lib_files & $").empty?
-        end
-      end
-    end
-
-    def load_paths_added?
-      # always try to add load paths - even if a gem is loaded, it may not
-      # be a compatible version (ie random_gem 0.4 is loaded and a later spec
-      # needs >= 0.5 - gem 'random_gem' will catch this and error out)
-      @load_paths_added
-    end
-
-    def install
-      cmd = "#{gem_command} #{install_command.join(' ')}"
-      puts cmd
-      puts %x(#{cmd})
-    end
-
-    def unpack_to(directory)
-      FileUtils.mkdir_p directory
-      Dir.chdir directory do
-        Gem::GemRunner.new.run(unpack_command)
-      end
-
-      # Gem.activate changes the spec - get the original
-      real_spec = Gem::Specification.load(specification.loaded_from)
-      write_spec(directory, real_spec)
-
-    end
-
-    def write_spec(directory, spec)
-      # copy the gem's specification into GEMDIR/.specification so that
-      # we can access information about the gem on deployment systems
-      # without having the gem installed
-      File.open(spec_filename(directory), 'w') do |file|
-        file.puts spec.to_yaml
-      end
-    end
-
-    def refresh_spec(directory)
-      real_gems = Gem.source_index.installed_source_index
-      exact_dep = Gem::Dependency.new(name, "= #{specification.version}")
-      matches = real_gems.search(exact_dep)
-      installed_spec = matches.first
-      if File.exist?(File.dirname(spec_filename(directory)))
-        if installed_spec
-          # we have a real copy
-          # get a fresh spec - matches should only have one element
-          # note that there is no reliable method to check that the loaded
-          # spec is the same as the copy from real_gems - Gem.activate changes
-          # some of the fields
-          real_spec = Gem::Specification.load(matches.first.loaded_from)
-          write_spec(directory, real_spec)
-          puts "Reloaded specification for #{name} from installed gems."
-        else
-          # the gem isn't installed locally - write out our current specs
-          write_spec(directory, specification)
-          puts "Gem #{name} not loaded locally - writing out current spec."
-        end
-      else
-        if framework_gem?
-          puts "Gem directory for #{name} not found - check if it's loading before rails."
-        else
-          puts "Something bad is going on - gem directory not found for #{name}."
-        end
-      end
-    end
-
-    def ==(other)
-      self.name == other.name && self.requirement == other.requirement
-    end
-    alias_method :"eql?", :"=="
-
-    def hash
-      @dep.hash
-    end
-
-    def specification
-      # code repeated from Gem.activate. Find a matching spec, or the currently loaded version.
-      # error out if loaded version and requested version are incompatible.
-      @spec ||= begin
-        matches = Gem.source_index.search(@dep)
-        matches << @@framework_gems[name] if framework_gem?
-        if Gem.loaded_specs[name] then
-          # This gem is already loaded.  If the currently loaded gem is not in the
-          # list of candidate gems, then we have a version conflict.
-          existing_spec = Gem.loaded_specs[name]
-          unless matches.any? { |spec| spec.version == existing_spec.version } then
-            raise Gem::Exception,
-                  "can't activate #{@dep}, already activated #{existing_spec.full_name}"
-          end
-          # we're stuck with it, so change to match
-          @dep.version_requirements = Gem::Requirement.create("=#{existing_spec.version}")
-          existing_spec
-        else
-          # new load
-          matches.last
-        end
-      end
-    end
-
-    private
-      def gem_command
-        RUBY_PLATFORM =~ /win32/ ? 'gem.bat' : 'gem'
-      end
-
-      def install_command
-        cmd = %w(install) << name
-        cmd << "--version" << %("#{requirement.to_s}") if requirement
-        cmd << "--source"  << @source  if @source
-        cmd
-      end
-
-      def unpack_command
-        cmd = %w(unpack) << name
-        cmd << "--version" << "= "+specification.version.to_s if requirement
-        cmd
-      end
-  end
-end

data/lib/rails/mongrel_server/commands.rb

@@ -1,342 +0,0 @@
-# Copyright (c) 2005 Zed A. Shaw
-# You can redistribute it and/or modify it under the same terms as Ruby.
-#
-# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html
-# for more information.
-
-require 'optparse'
-require 'yaml'
-require 'etc'
-
-require 'mongrel'
-require 'rails/mongrel_server/handler'
-
-module Rails
-  module MongrelServer
-    def self.send_signal(signal, pid_file)
-      pid = open(pid_file).read.to_i
-      print "Sending #{signal} to Mongrel at PID #{pid}..."
-      begin
-        Process.kill(signal, pid)
-      rescue Errno::ESRCH
-        puts "Process does not exist.  Not running."
-      end
-
-      puts "Done."
-    end
-
-    class RailsConfigurator < Mongrel::Configurator
-      def setup_mime_types
-        mime = {}
-
-        if defaults[:mime_map]
-          Mongrel.log("Loading additional MIME types from #{defaults[:mime_map]}")
-          mime = load_mime_map(defaults[:mime_map], mime)
-        end
-
-        mime.each {|k,v| Mongrel::DirHandler::add_mime_type(k,v) }
-      end
-
-      def mount_rails(prefix)
-        ENV['RAILS_ENV'] = defaults[:environment]
-        ::RAILS_ENV.replace(defaults[:environment]) if defined?(::RAILS_ENV)
-
-        env_location = "#{defaults[:cwd]}/config/environment"
-        require env_location
-
-        ActionController::Base.relative_url_root = defaults[:prefix]
-        uri prefix, :handler => Rails::MongrelServer::RailsHandler.new
-      end
-    end
-
-    class Start < GemPlugin::Plugin "/commands"
-      include Mongrel::Command::Base
-
-      def configure
-        options [
-          ["-e", "--environment ENV", "Rails environment to run as", :@environment, ENV['RAILS_ENV'] || "development"],
-          ["-d", "--daemonize", "Run daemonized in the background", :@daemon, false],
-          ['-p', '--port PORT', "Which port to bind to", :@port, 3000],
-          ['-a', '--address ADDR', "Address to bind to", :@address, "0.0.0.0"],
-          ['-l', '--log FILE', "Where to write log messages", :@log_file, "log/mongrel.log"],
-          ['-P', '--pid FILE', "Where to write the PID", :@pid_file, "tmp/pids/mongrel.pid"],
-          ['-n', '--num-procs INT', "Number of processors active before clients denied", :@num_procs, 1024],
-          ['-o', '--timeout TIME', "Time to wait (in seconds) before killing a stalled thread", :@timeout, 60],
-          ['-t', '--throttle TIME', "Time to pause (in hundredths of a second) between accepting clients", :@throttle, 0],
-          ['-m', '--mime PATH', "A YAML file that lists additional MIME types", :@mime_map, nil],
-          ['-c', '--chdir PATH', "Change to dir before starting (will be expanded)", :@cwd, RAILS_ROOT],
-          ['-r', '--root PATH', "Set the document root (default 'public')", :@docroot, "public"],
-          ['-B', '--debug', "Enable debugging mode", :@debug, false],
-          ['-C', '--config PATH', "Use a config file", :@config_file, nil],
-          ['-S', '--script PATH', "Load the given file as an extra config script", :@config_script, nil],
-          ['-G', '--generate PATH', "Generate a config file for use with -C", :@generate, nil],
-          ['', '--user USER', "User to run as", :@user, nil],
-          ['', '--group GROUP', "Group to run as", :@group, nil],
-          ['', '--prefix PATH', "URL prefix for Rails app", :@prefix, nil],
-
-          ['-b', '--binding ADDR', "Address to bind to (deprecated, use -a)", :@address, "0.0.0.0"],
-          ['-u', '--debugger', "Enable debugging mode (deprecated, use -B)", :@debug, false]
-        ]
-      end
-
-      def validate
-        if @config_file
-          valid_exists?(@config_file, "Config file not there: #@config_file")
-          return false unless @valid
-          @config_file = File.expand_path(@config_file)
-          load_config
-          return false unless @valid
-        end
-
-        @cwd = File.expand_path(@cwd)
-        valid_dir? @cwd, "Invalid path to change to during daemon mode: #@cwd"
-
-        # Change there to start, then we'll have to come back after daemonize
-        Dir.chdir(@cwd)
-
-        valid?(@prefix[0] == ?/ && @prefix[-1] != ?/, "Prefix must begin with / and not end in /") if @prefix
-        valid_dir? File.dirname(@log_file), "Path to log file not valid: #@log_file"
-        valid_dir? File.dirname(@pid_file), "Path to pid file not valid: #@pid_file"
-        valid_dir? @docroot, "Path to docroot not valid: #@docroot"
-        valid_exists? @mime_map, "MIME mapping file does not exist: #@mime_map" if @mime_map
-        valid_exists? @config_file, "Config file not there: #@config_file" if @config_file
-        valid_dir? File.dirname(@generate), "Problem accessing directory to #@generate" if @generate
-        valid_user? @user if @user
-        valid_group? @group if @group
-
-        return @valid
-      end
-
-      def run
-        if @generate
-          @generate = File.expand_path(@generate)
-          Mongrel.log(:error, "** Writing config to \"#@generate\".")
-          open(@generate, "w") {|f| f.write(settings.to_yaml) }
-          Mongrel.log(:error, "** Finished.  Run \"mongrel_rails start -C #@generate\" to use the config file.")
-          exit 0
-        end
-
-        config = RailsConfigurator.new(settings) do
-          defaults[:log] = $stdout if defaults[:environment] == 'development'
-
-          Mongrel.log("=> Rails #{Rails.version} application starting on http://#{defaults[:host]}:#{defaults[:port]}")
-
-          unless defaults[:daemon]
-            Mongrel.log("=> Call with -d to detach")
-            Mongrel.log("=> Ctrl-C to shutdown server")
-            start_debugger if defaults[:debug]
-          end
-
-          if defaults[:daemon]
-            if File.exist? defaults[:pid_file]
-              Mongrel.log(:error, "!!! PID file #{defaults[:pid_file]} already exists.  Mongrel could be running already.  Check your #{defaults[:log_file]} for errors.")
-              Mongrel.log(:error, "!!! Exiting with error.  You must stop mongrel and clear the .pid before I'll attempt a start.")
-              exit 1
-            end
-
-            daemonize
-
-            Mongrel.log("Daemonized, any open files are closed.  Look at #{defaults[:pid_file]} and #{defaults[:log_file]} for info.")
-            Mongrel.log("Settings loaded from #{@config_file} (they override command line).") if @config_file
-          end
-
-          Mongrel.log("Starting Mongrel listening at #{defaults[:host]}:#{defaults[:port]}, further information can be found in log/mongrel-#{defaults[:host]}-#{defaults[:port]}.log")
-
-          listener do
-            prefix = defaults[:prefix] || '/'
-
-            if defaults[:debug]
-              Mongrel.log("Installing debugging prefixed filters. Look in log/mongrel_debug for the files.")
-              debug(prefix)
-            end
-
-            setup_mime_types
-            dir_handler = Mongrel::DirHandler.new(defaults[:docroot], false)
-            dir_handler.passthrough_missing_files = true
-
-            unless defaults[:environment] == 'production'
-              Mongrel.log("Mounting DirHandler at #{prefix}...")
-              uri prefix, :handler => dir_handler
-            end
-
-
-            Mongrel.log("Starting Rails with #{defaults[:environment]} environment...")
-            Mongrel.log("Mounting Rails at #{prefix}...")
-            mount_rails(prefix)
-            Mongrel.log("Rails loaded.")
-
-
-            Mongrel.log("Loading any Rails specific GemPlugins" )
-            load_plugins
-
-            if defaults[:config_script]
-              Mongrel.log("Loading #{defaults[:config_script]} external config script")
-              run_config(defaults[:config_script])
-            end
-
-            setup_signals
-          end
-        end
-
-        config.run
-        Mongrel.log("Mongrel #{Mongrel::Const::MONGREL_VERSION} available at #{@address}:#{@port}")
-
-        if config.defaults[:daemon]
-          config.write_pid_file
-        else
-          Mongrel.log("Use CTRL-C to stop.")
-          tail "log/#{config.defaults[:environment]}.log"
-        end
-
-        config.join
-
-        if config.needs_restart
-          unless RUBY_PLATFORM =~ /djgpp|(cyg|ms|bcc)win|mingw/
-            cmd = "ruby #{__FILE__} start #{original_args.join(' ')}"
-            Mongrel.log("Restarting with arguments:  #{cmd}")
-            config.stop(false, true)
-            config.remove_pid_file
-
-            if config.defaults[:daemon]
-              system cmd
-            else
-              Mongrel.log(:error, "Can't restart unless in daemon mode.")
-              exit 1
-            end
-          else
-            Mongrel.log("Win32 does not support restarts. Exiting.")
-          end
-        end
-      end
-
-      def load_config
-        settings = {}
-        begin
-          settings = YAML.load_file(@config_file)
-        ensure
-          Mongrel.log(:error, "** Loading settings from #{@config_file} (they override command line).") unless @daemon || settings[:daemon]
-        end
-
-        settings[:includes] ||= ["mongrel"]
-
-        # Config file settings will override command line settings
-        settings.each do |key, value|
-          key = key.to_s
-          if config_keys.include?(key)
-            key = 'address' if key == 'host'
-            self.instance_variable_set("@#{key}", value)
-          else
-            failure "Unknown configuration setting: #{key}"
-            @valid = false
-          end
-        end
-      end
-
-      def config_keys
-        @config_keys ||=
-          %w(address host port cwd log_file pid_file environment docroot mime_map daemon debug includes config_script num_processors timeout throttle user group prefix)
-      end
-
-      def settings
-        config_keys.inject({}) do |hash, key|
-          value = self.instance_variable_get("@#{key}")
-          key = 'host' if key == 'address'
-          hash[key.to_sym] ||= value
-          hash
-        end
-      end
-
-      def start_debugger
-        require_library_or_gem 'ruby-debug'
-        Debugger.start
-        Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
-        Mongrel.log("=> Debugger enabled")
-      rescue Exception
-        Mongrel.log(:error, "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'")
-        exit
-      end
-
-      def tail(log_file)
-        cursor = File.size(log_file)
-        last_checked = Time.now
-        tail_thread = Thread.new do
-          File.open(log_file, 'r') do |f|
-            loop do
-              f.seek cursor
-              if f.mtime > last_checked
-                last_checked = f.mtime
-                contents = f.read
-                cursor += contents.length
-                print contents
-              end
-              sleep 1
-            end
-          end
-        end
-        tail_thread
-      end
-    end
-
-    class Stop < GemPlugin::Plugin "/commands"
-      include Mongrel::Command::Base
-
-      def configure
-        options [
-          ['-c', '--chdir PATH', "Change to dir before starting (will be expanded).", :@cwd, "."],
-          ['-f', '--force', "Force the shutdown (kill -9).", :@force, false],
-          ['-w', '--wait SECONDS', "Wait SECONDS before forcing shutdown", :@wait, "0"],
-          ['-P', '--pid FILE', "Where the PID file is located.", :@pid_file, "log/mongrel.pid"]
-        ]
-      end
-
-      def validate
-        @cwd = File.expand_path(@cwd)
-        valid_dir? @cwd, "Invalid path to change to during daemon mode: #@cwd"
-
-        Dir.chdir @cwd
-
-        valid_exists? @pid_file, "PID file #@pid_file does not exist.  Not running?"
-        return @valid
-      end
-
-      def run
-        if @force
-          @wait.to_i.times do |waiting|
-            exit(0) if not File.exist? @pid_file
-            sleep 1
-          end
-
-          Mongrel::send_signal("KILL", @pid_file) if File.exist? @pid_file
-        else
-          Mongrel::send_signal("TERM", @pid_file)
-        end
-      end
-    end
-
-
-    class Restart < GemPlugin::Plugin "/commands"
-      include Mongrel::Command::Base
-
-      def configure
-        options [
-          ['-c', '--chdir PATH', "Change to dir before starting (will be expanded)", :@cwd, '.'],
-          ['-P', '--pid FILE', "Where the PID file is located", :@pid_file, "log/mongrel.pid"]
-        ]
-      end
-
-      def validate
-        @cwd = File.expand_path(@cwd)
-        valid_dir? @cwd, "Invalid path to change to during daemon mode: #@cwd"
-
-        Dir.chdir @cwd
-
-        valid_exists? @pid_file, "PID file #@pid_file does not exist.  Not running?"
-        return @valid
-      end
-
-      def run
-        MongrelServer::send_signal("USR2", @pid_file)
-      end
-    end
-  end
-end