1: # empty gem_prelude.rb
    2: #
    3: # p Gem::Enable
    4: 
    5: if defined?(Gem::Enable) && Gem::Enable
    6: #t = Time.now
    7:   
    8: module Kernel
    9: 
   10:   def gem(gem_name, *version_requirements)
   11:     Gem.push_gem_version_on_load_path(gem_name, *version_requirements)
   12:   end
   13: 
   14: end
   15: 
   16: module Gem
   17:   
   18:   ConfigMap = {
   19:     :sitedir => RbConfig::CONFIG["sitedir"],
   20:     :ruby_version => RbConfig::CONFIG["ruby_version"],
   21:     :libdir => RbConfig::CONFIG["libdir"],
   22:     :sitelibdir => RbConfig::CONFIG["sitelibdir"],
   23:     :arch => RbConfig::CONFIG["arch"],
   24:     :bindir => RbConfig::CONFIG["bindir"],
   25:     :EXEEXT => RbConfig::CONFIG["EXEEXT"],
   26:     :RUBY_SO_NAME => RbConfig::CONFIG["RUBY_SO_NAME"],
   27:     :ruby_install_name => RbConfig::CONFIG["ruby_install_name"]
   28:   }
   29: 
   30:   class << self
   31: 
   32:     def default_dir
   33:       if defined? RUBY_FRAMEWORK_VERSION
   34:         return File.join(File.dirname(ConfigMap[:sitedir]), "Gems")
   35:       else
   36:         File.join(ConfigMap[:libdir], 'ruby', 'gems', ConfigMap[:ruby_version])
   37:       end
   38:     end
   39: 
   40:     def dir
   41:       @gem_home ||= nil
   42:       set_home(ENV['GEM_HOME'] || default_dir) unless @gem_home
   43:       @gem_home
   44:     end
   45: 
   46:     def path
   47:       @gem_path ||= nil
   48:       unless @gem_path
   49:         paths = [ENV['GEM_PATH']]
   50:         paths << APPLE_GEM_HOME if defined? APPLE_GEM_HOME
   51:         set_paths(paths.compact.join(File::PATH_SEPARATOR))
   52:       end
   53:       @gem_path
   54:     end
   55: 
   56:     # Set the Gem home directory (as reported by +dir+).
   57:     def set_home(home)
   58:       @gem_home = home
   59:       ensure_gem_subdirectories(@gem_home)
   60:     end
   61: 
   62:     def set_paths(gpaths)
   63:       if gpaths
   64:         @gem_path = gpaths.split(File::PATH_SEPARATOR)
   65:         @gem_path << Gem.dir
   66:       else
   67:         @gem_path = [Gem.dir]
   68:       end
   69:       @gem_path.uniq!
   70:       @gem_path.each do |gp| ensure_gem_subdirectories(gp) end
   71:     end
   72:     
   73:     def ensure_gem_subdirectories(path)
   74:     end
   75: 
   76:   end
   77: 
   78:   module QuickLoader
   79: 
   80:     class << self
   81:       def load_full_rubygems_library
   82:         class << Gem
   83:           Gem.methods(false).each do |method_name|
   84:             undef_method method_name
   85:           end
   86:         end
   87: 
   88:         Kernel.send :undef_method, :gem
   89: 
   90:         $".delete File.join(Gem::ConfigMap[:libdir], 'ruby',
   91:                             Gem::ConfigMap[:ruby_version], 'rubygems.rb')
   92: 
   93:         require 'rubygems'
   94:       end
   95:     end
   96: 
   97:     GemPaths = {}
   98:     GemVersions = {}
   99:     
  100:     def push_gem_version_on_load_path(gem_name, *version_requirements)
  101:       if version_requirements.empty?
  102:         unless GemPaths.has_key?(gem_name)
  103:           raise LoadError.new("Could not find RubyGem #{gem_name} (>= 0)\n") 
  104:         end
  105:         # highest version gems already active
  106:         return false
  107:       else
  108:         if version_requirements.length > 1
  109:           QuickLoader.load_full_rubygems_library
  110:           return gem(gem_name, *version_requirements)
  111:         end
  112:         requirement, version = version_requirements[0].split
  113:         requirement.strip!
  114:         if requirement == ">" || requirement == ">="
  115:           if (GemVersions[gem_name] <=> Gem.calculate_integers_for_gem_version(version)) >= 0
  116:             return false 
  117:           end
  118:         elsif requirement == "~>"
  119:           loaded_version = GemVersions[gem_name]
  120:           required_version = Gem.calculate_integers_for_gem_version(version)
  121:           if loaded_version && (loaded_version[0] == required_version[0])
  122:             return false
  123:           end
  124:         end
  125:         QuickLoader.load_full_rubygems_library
  126:         gem(gem_name, *version_requirements)
  127:       end
  128:     end
  129: 
  130:     def calculate_integers_for_gem_version(gem_version)
  131:       numbers = gem_version.split(".").collect {|n| n.to_i}
  132:       numbers.pop while numbers.last == 0
  133:       numbers << 0 if numbers.empty?
  134:       numbers
  135:     end
  136:   
  137:     def push_all_highest_version_gems_on_load_path
  138:       Gem.path.each do |path|
  139:         gems_directory = File.join(path, "gems")
  140:         if File.exist?(gems_directory)
  141:           Dir.entries(gems_directory).each do |gem_directory_name|
  142:             next if gem_directory_name == "." || gem_directory_name == ".."
  143:             dash = gem_directory_name.rindex("-")
  144:             next if dash.nil?
  145:             gem_name = gem_directory_name[0...dash]
  146:             current_version = GemVersions[gem_name]
  147:             new_version = calculate_integers_for_gem_version(gem_directory_name[dash+1..-1])
  148:             if current_version
  149:               if (current_version <=> new_version) == -1
  150:                 GemVersions[gem_name] = new_version
  151:                 GemPaths[gem_name] = File.join(gems_directory, gem_directory_name)
  152:               end
  153:             else
  154:               GemVersions[gem_name] = new_version
  155:               GemPaths[gem_name] = File.join(gems_directory, gem_directory_name)
  156:             end
  157:           end
  158:         end
  159:       end
  160:       require_paths = []
  161:       GemPaths.values.each do |path|
  162:         if File.exist?(File.join(path, ".require_paths"))
  163:           require_paths.concat(File.read(File.join(path, ".require_paths")).split.map {|require_path| File.join(path, require_path)})
  164:         else
  165:           require_paths << File.join(path, "bin") if File.exist?(File.join(path, "bin"))
  166:           require_paths << File.join(path, "lib") if File.exist?(File.join(path, "lib"))
  167:         end
  168:       end
  169: 
  170:       # gem directories must come after -I and ENV['RUBYLIB']
  171:       $:[$:.index(ConfigMap[:sitelibdir]),0] = require_paths
  172:     end
  173: 
  174:     def const_missing(constant)
  175:       QuickLoader.load_full_rubygems_library
  176:       Gem.const_get(constant)
  177:     end
  178: 
  179:     def method_missing(method, *args, &block)
  180:       QuickLoader.load_full_rubygems_library
  181:       super unless Gem.respond_to?(method)
  182:       Gem.send(method, *args, &block)
  183:     end
  184:   end
  185:   
  186:   extend QuickLoader
  187: 
  188: end
  189: 
  190: begin
  191:   Gem.push_all_highest_version_gems_on_load_path
  192:   $" << File.join(Gem::ConfigMap[:libdir], "ruby",
  193:                   Gem::ConfigMap[:ruby_version], "rubygems.rb")
  194: rescue Exception => e
  195:   puts "Error loading gem paths on load path in gem_prelude"
  196:   puts e
  197:   puts e.backtrace.join("\n")
  198: end
  199: 
  200: #puts "Gem load in #{Time.now - t} seconds"
  201: end # Gem::Enable