rails_csi 2.3.5.p6

data/lib/performance_test_help.rb

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

data/lib/rails/backtrace_cleaner.rb

@@ -0,0 +1,54 @@
+module Rails
+  class BacktraceCleaner < ActiveSupport::BacktraceCleaner
+    ERB_METHOD_SIG = /:in `_run_erb_.*/
+
+    RAILS_GEMS   = %w( actionpack activerecord actionmailer activesupport activeresource rails )
+
+    VENDOR_DIRS  = %w( vendor/rails )
+    SERVER_DIRS  = %w( lib/mongrel bin/mongrel
+                       lib/passenger bin/passenger-spawn-server
+                       lib/rack )
+    RAILS_NOISE  = %w( script/server )
+    RUBY_NOISE   = %w( rubygems/custom_require benchmark.rb )
+
+    ALL_NOISE    = VENDOR_DIRS + SERVER_DIRS + RAILS_NOISE + RUBY_NOISE
+
+    def initialize
+      super
+      add_filter   { |line| line.sub("#{RAILS_ROOT}/", '') }
+      add_filter   { |line| line.sub(ERB_METHOD_SIG, '') }
+      add_filter   { |line| line.sub('./', '/') } # for tests
+
+      add_gem_filters
+
+      add_silencer { |line| ALL_NOISE.any? { |dir| line.include?(dir) } }
+      add_silencer { |line| RAILS_GEMS.any? { |gem| line =~ /^#{gem} / } }
+      add_silencer { |line| line =~ %r(vendor/plugins/[^\/]+/lib) }
+    end
+    
+    
+    private
+      def add_gem_filters
+        Gem.path.each do |path|
+          # http://gist.github.com/30430
+          add_filter { |line| line.sub(/(#{path})\/gems\/([a-z]+)-([0-9.]+)\/(.*)/, '\2 (\3) \4')}
+        end
+
+        vendor_gems_path = Rails::GemDependency.unpacked_path.sub("#{RAILS_ROOT}/",'')
+        add_filter { |line| line.sub(/(#{vendor_gems_path})\/([a-z]+)-([0-9.]+)\/(.*)/, '\2 (\3) [v] \4')}
+      end
+  end
+
+  # For installing the BacktraceCleaner in the test/unit
+  module BacktraceFilterForTestUnit #:nodoc:
+    def self.included(klass)
+      klass.send :alias_method_chain, :filter_backtrace, :cleaning
+    end
+
+    def filter_backtrace_with_cleaning(backtrace, prefix=nil)
+      backtrace = filter_backtrace_without_cleaning(backtrace, prefix)
+      backtrace = backtrace.first.split("\n") if backtrace.size == 1
+      Rails.backtrace_cleaner.clean(backtrace)
+    end
+  end
+end

data/lib/rails/gem_builder.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,311 @@
+require 'rails/vendor_gem_source_index'
+
+module Gem
+  def self.source_index=(index)
+    @@source_index = index
+  end
+end
+
+module Rails
+  class GemDependency < Gem::Dependency
+    attr_accessor :lib, :source, :dep
+
+    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 self.from_directory_name(directory_name, load_spec=true)
+      directory_name_parts = File.basename(directory_name).split('-')
+      name    = directory_name_parts[0..-2].join('-')
+      version = directory_name_parts.last
+      result = self.new(name, :version => version)
+      spec_filename = File.join(directory_name, '.specification')
+      if load_spec
+        raise "Missing specification file in #{File.dirname(spec_filename)}. Perhaps you need to do a 'rake gems:refresh_specs'?" unless File.exists?(spec_filename)
+        spec = YAML::load_file(spec_filename)
+        result.specification = spec
+      end
+      result
+    rescue ArgumentError => e
+      raise "Unable to determine gem name and version from '#{directory_name}'"
+    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
+
+      @lib      = options[:lib]
+      @source   = options[:source]
+      @loaded   = @frozen = @load_paths_added = false
+
+      super(name, req)
+    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 self
+      @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?
+      return [] unless installed?
+      specification.dependencies.reject do |dependency|
+        dependency.type == :development
+      end.map do |dependency|
+        GemDependency.new(dependency.name, :requirement => dependency.version_requirements)
+      end
+    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(self)
+        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
+          version_requirements = Gem::Requirement.create("=#{existing_spec.version}")
+          existing_spec
+        else
+          # new load
+          matches.last
+        end
+      end
+    end
+
+    def specification=(s)
+      @spec = s
+    end
+
+    def requirement
+      r = version_requirements
+      (r == Gem::Requirement.default) ? nil : r
+    end
+
+    def built?
+      return false unless frozen?
+
+      if vendor_gem?
+        specification.extensions.each do |ext|
+          makefile = File.join(unpacked_gem_directory, File.dirname(ext), 'Makefile')
+          return false unless File.exists?(makefile)
+        end
+      end
+
+      true
+    end
+
+    def framework_gem?
+      @@framework_gems.has_key?(name)
+    end
+
+    def frozen?
+      @frozen ||= vendor_rails? || vendor_gem?
+    end
+
+    def installed?
+      Gem.loaded_specs.keys.include?(name)
+    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 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 vendor_rails?
+      Gem.loaded_specs.has_key?(name) && Gem.loaded_specs[name].loaded_from.empty?
+    end
+
+    def vendor_gem?
+      specification && File.exists?(unpacked_gem_directory)
+    end
+
+    def build(options={})
+      require 'rails/gem_builder'
+      return if specification.nil?
+      if options[:force] || !built?
+        return unless File.exists?(unpacked_specification_filename)
+        spec = YAML::load_file(unpacked_specification_filename)
+        Rails::GemBuilder.new(spec, unpacked_gem_directory).build_extensions
+        puts "Built gem: '#{unpacked_gem_directory}'"
+      end
+      dependencies.each { |dep| dep.build(options) }
+    end
+
+    def install
+      unless installed?
+        cmd = "#{gem_command} #{install_command.join(' ')}"
+        puts cmd
+        puts %x(#{cmd})
+      end
+    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 refresh
+      Rails::VendorGemSourceIndex.silence_spec_warnings = true
+      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 frozen?
+        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_specification(real_spec)
+          puts "Reloaded specification for #{name} from installed gems."
+        else
+          # the gem isn't installed locally - write out our current specs
+          write_specification(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 unpack(options={})
+      unless frozen? || framework_gem?
+        FileUtils.mkdir_p unpack_base
+        Dir.chdir unpack_base 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_specification(real_spec)
+      end
+      dependencies.each { |dep| dep.unpack(options) } if options[:recursive]
+    end
+
+    def write_specification(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(unpacked_specification_filename, 'w') do |file|
+        file.puts spec.to_yaml
+      end
+    end
+
+    def ==(other)
+      self.name == other.name && self.requirement == other.requirement
+    end
+    alias_method :"eql?", :"=="
+
+    private
+
+      def gem_command
+        case RUBY_PLATFORM
+          when /win32/
+            'gem.bat'
+          when /java/
+            'jruby -S gem'
+          else
+            'gem'
+        end
+      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
+
+      def unpack_base
+        Rails::GemDependency.unpacked_path
+      end
+
+      def unpacked_gem_directory
+        File.join(unpack_base, specification.full_name)
+      end
+
+      def unpacked_specification_filename
+        File.join(unpacked_gem_directory, '.specification')
+      end
+
+  end
+end

data/lib/rails/plugin.rb

@@ -0,0 +1,179 @@
+module Rails
+  # The Plugin class should be an object which provides the following methods:
+  #
+  # * +name+       - Used during initialisation to order the plugin (based on name and
+  #                  the contents of <tt>config.plugins</tt>).
+  # * +valid?+     - Returns true if this plugin can be loaded.
+  # * +load_paths+ - Each path within the returned array will be added to the <tt>$LOAD_PATH</tt>.
+  # * +load+       - Finally 'load' the plugin.
+  #
+  # These methods are expected by the Rails::Plugin::Locator and Rails::Plugin::Loader classes.
+  # The default implementation returns the <tt>lib</tt> directory as its <tt>load_paths</tt>, 
+  # and evaluates <tt>init.rb</tt> when <tt>load</tt> is called.
+  #
+  # You can also inspect the about.yml data programmatically:
+  #
+  #   plugin = Rails::Plugin.new(path_to_my_plugin)
+  #   plugin.about["author"] # => "James Adam"
+  #   plugin.about["url"] # => "http://interblah.net"
+  class Plugin
+    include Comparable
+    
+    attr_reader :directory, :name
+    
+    def initialize(directory)
+      @directory = directory
+      @name      = File.basename(@directory) rescue nil
+      @loaded    = false
+    end
+    
+    def valid?
+      File.directory?(directory) && (has_app_directory? || has_lib_directory? || has_init_file?)
+    end
+  
+    # Returns a list of paths this plugin wishes to make available in <tt>$LOAD_PATH</tt>.
+    def load_paths
+      report_nonexistant_or_empty_plugin! unless valid?
+      
+      returning [] do |load_paths|
+        load_paths << lib_path  if has_lib_directory?
+        load_paths << app_paths if has_app_directory?
+      end.flatten
+    end
+    
+    # Evaluates a plugin's init.rb file.
+    def load(initializer)
+      return if loaded?
+      report_nonexistant_or_empty_plugin! unless valid?
+      evaluate_init_rb(initializer)
+      @loaded = true
+    end
+    
+    def loaded?
+      @loaded
+    end
+    
+    def <=>(other_plugin)
+      name <=> other_plugin.name
+    end
+
+    def about
+      @about ||= load_about_information
+    end
+
+    # Engines are plugins with an app/ directory.
+    def engine?
+      has_app_directory?
+    end
+    
+    # Returns true if the engine ships with a routing file
+    def routed?
+      File.exist?(routing_file)
+    end
+
+    # Returns true if there is any localization file in locale_path
+    def localized?
+      locale_files.any?
+    end
+
+    def view_path
+      File.join(directory, 'app', 'views')
+    end
+
+    def controller_path
+      File.join(directory, 'app', 'controllers')
+    end
+
+    def metal_path
+      File.join(directory, 'app', 'metal')
+    end
+
+    def routing_file
+      File.join(directory, 'config', 'routes.rb')
+    end
+
+    def locale_path
+      File.join(directory, 'config', 'locales')
+    end
+
+    def locale_files
+      Dir[ File.join(locale_path, '*.{rb,yml}') ]
+    end
+    
+
+    private
+      def load_about_information
+        about_yml_path = File.join(@directory, "about.yml")
+        parsed_yml = File.exist?(about_yml_path) ? YAML.load(File.read(about_yml_path)) : {}
+        parsed_yml || {}
+      rescue Exception
+        {}
+      end
+
+      def report_nonexistant_or_empty_plugin!
+        raise LoadError, "Can not find the plugin named: #{name}"
+      end
+
+      
+      def app_paths
+        [ File.join(directory, 'app', 'models'), File.join(directory, 'app', 'helpers'), controller_path, metal_path ]
+      end
+      
+      def lib_path
+        File.join(directory, 'lib')
+      end
+
+      def classic_init_path
+        File.join(directory, 'init.rb')
+      end
+
+      def gem_init_path
+        File.join(directory, 'rails', 'init.rb')
+      end
+
+      def init_path
+        File.file?(gem_init_path) ? gem_init_path : classic_init_path
+      end
+
+
+      def has_app_directory?
+        File.directory?(File.join(directory, 'app'))
+      end
+
+      def has_lib_directory?
+        File.directory?(lib_path)
+      end
+
+      def has_init_file?
+        File.file?(init_path)
+      end
+
+
+      def evaluate_init_rb(initializer)
+        if has_init_file?
+          silence_warnings do
+            # Allow plugins to reference the current configuration object
+            config = initializer.configuration
+            
+            eval(IO.read(init_path), binding, init_path)
+          end
+        end
+      end               
+  end
+
+  # This Plugin subclass represents a Gem plugin. Although RubyGems has already
+  # taken care of $LOAD_PATHs, it exposes its load_paths to add them
+  # to Dependencies.load_paths.
+  class GemPlugin < Plugin
+    # Initialize this plugin from a Gem::Specification.
+    def initialize(spec, gem)
+      directory = spec.full_gem_path
+      super(directory)
+      @name = spec.name
+    end
+
+    def init_path
+      File.join(directory, 'rails', 'init.rb')
+    end
+  end
+end