minigems 0.9.3 → 0.9.4

data/README

@@ -34,6 +34,21 @@ rescue LoadError
   require 'rubygems'
 end
 
+For best performance, use the Kernel#gem() method to load up the correct gem,
+before doing any requires from it, preventing a more expensive glob operation.
+
+The following:
+
+require 'spec/task/spectask'
+
+Can be easily improved as follows:
+
+gem 'rspec'
+require 'spec/task/spectask'
+
+This is especially the case when there's no one-to-one mapping between the
+file to require and de gem name (spec vs. rspec in the example above).
+
 There's currently a patch pending on RubyForge, to get minigems into the 
 standard, rubygems system. If you like minigems, please post a vote/followup:
 

data/Rakefile

@@ -15,7 +15,7 @@ GEM_EMAIL  = "info@atelierfabien.be"
 
 GEM_NAME    = "minigems"
 PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
-GEM_VERSION = (Gem::MiniGems::VERSION || "0.9.3") + PKG_BUILD
+GEM_VERSION = (Gem::MiniGems::VERSION || "0.9.4") + PKG_BUILD
 
 RELEASE_NAME    = "REL #{GEM_VERSION}"
 

data/lib/minigems.rb

@@ -1,8 +1,9 @@
 module Gem
 unless const_defined?(:MiniGems)
   module MiniGems
-    VERSION = "0.9.3"
-  
+    
+    VERSION = "0.9.4"
+    
     # The next line needs to be kept exactly as shown; it's being replaced
     # during minigems installation.
     FULL_RUBYGEMS_METHODS = []
@@ -19,15 +20,14 @@ end
 # Enable minigems unless rubygems has already loaded.
 unless $LOADED_FEATURES.include?("rubygems.rb")
 
-  # Prevent full rubygems from loading
   $LOADED_FEATURES << "rubygems.rb"
-  require "rubygems/version"
-  require "rubygems/rubygems_version"
-  require "rubygems/requirement"
-  require "rubygems/dependency"
-  require "rubygems/specification"
-  require "rbconfig"
-  require "pathname"
+  require 'minigems/core'
+  require 'rubygems/specification'
+  require 'pathname'
+  
+  unless Gem::MiniGems.const_defined?(:INLINE_REGEXP)
+    Gem::MiniGems::INLINE_REGEXP = /^Inline_.*?\.#{Config::CONFIG['DLEXT']}/
+  end
 
   module Kernel
   
@@ -35,29 +35,40 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
       Gem.activate(name, *versions)
     end
   
-    alias :gem_original_require :require
+    if RUBY_VERSION < '1.9' then
+  
+      alias :gem_original_require :require
 
-    # We replace Ruby's require with our own, which is capable of
-    # loading gems on demand.
-    #
-    # When you call <tt>require 'x'</tt>, this is what happens:
-    # * If the file can be loaded from the existing Ruby loadpath, it
-    #   is.
-    # * Otherwise, installed gems are searched for a file that matches.
-    #   If it's found in gem 'y', that gem is activated (added to the
-    #   loadpath).
-    #
-    # The normal <tt>require</tt> functionality of returning false if
-    # that file has already been loaded is preserved.
-    #
-    def require(path) # :nodoc:
-      gem_original_require path
-    rescue LoadError => load_error
-      if load_error.message =~ /#{Regexp.escape path}\z/ && Gem.activate(path)
-        gem_original_require(path)
-      else
+      # We replace Ruby's require with our own, which is capable of
+      # loading gems on demand.
+      #
+      # When you call <tt>require 'x'</tt>, this is what happens:
+      # * If the file can be loaded from the existing Ruby loadpath, it
+      #   is.
+      # * Otherwise, installed gems are searched for a file that matches.
+      #   If it's found in gem 'y', that gem is activated (added to the
+      #   loadpath).
+      #
+      # The normal <tt>require</tt> functionality of returning false if
+      # that file has already been loaded is preserved.
+      #
+      def require(path) # :nodoc:
+        gem_original_require path
+      rescue LoadError => load_error
+        if File.basename(path).match(Gem::MiniGems::INLINE_REGEXP)
+          return true # RubyInline dynamicly created .so/.bundle
+        elsif load_error.message =~ /#{Regexp.escape path}\z/
+          if !path.include?('/') && (match = Gem.find_name(path))
+            Gem.activate_gem_from_path(match.first)
+            return gem_original_require(path)
+          elsif (spec = (Gem.find_in_source_path(path) || Gem.find_in_source_index(path)))
+            Gem.activate(spec.name, "= #{spec.version}")
+            return gem_original_require(path)
+          end
+        end
         raise load_error
       end
+      
     end
   
   end
@@ -68,15 +79,6 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
   
     class Exception < RuntimeError; end
   
-    class LoadError < ::LoadError
-      attr_accessor :name, :version_requirement
-    end
-  
-    # Whether minigems is being used or full rubygems has taken over.
-    def self.minigems?
-      not const_defined?(:SourceIndex)
-    end
-  
     # Keep track of loaded gems, maps gem name to full_name.
     def self.loaded_gems
       @loaded_gems ||= {}
@@ -92,7 +94,7 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
     def self.available?(name, *version_requirements)
       version_requirements = Gem::Requirement.default if version_requirements.empty?
       gem = Gem::Dependency.new(name, version_requirements)
-      not find(gem).nil?
+      not find_name(gem).nil?
     end
 
     # Activates an installed gem matching +gem+.  The gem must satisfy
@@ -110,12 +112,10 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
     # More information on version requirements can be found in the
     # Gem::Requirement and Gem::Version documentation.
     def self.activate(gem, *version_requirements)
-      if match = find(gem, *version_requirements)
+      if match = find_name(gem, *version_requirements)
         activate_gem_from_path(match.first)
-      elsif match = find(MiniGems.camel_case(gem), *version_requirements)
+      elsif match = find_name(MiniGems.camel_case(gem), *version_requirements)
         activate_gem_from_path(match.first)
-      elsif activate_from_source_path(gem)
-        true # The gem for the specified file was loaded correctly
       else
         unless gem.respond_to?(:name) && gem.respond_to?(:version_requirements)
           gem = Gem::Dependency.new(gem, version_requirements)
@@ -235,9 +235,14 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
     end
     
     # Find a file in the source path and activate its gem (best/highest match).
-    def self.activate_from_source_path(name)
-      matched_paths = self.path.map do |path| 
-        [Pathname.new("#{path}/gems"), Dir["#{path}/gems/**/#{name}{,.rb,.rbw,.so,.bundle,.dll,.sl,.jar}"]]
+    def self.find_in_source_path(path)
+      if ['.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar'].include?(File.extname(path))
+        file_path = path
+      else
+        file_path = "#{path}.rb"
+      end
+      matched_paths = self.path.map do |gem_path| 
+        [Pathname.new("#{gem_path}/gems"), Dir["#{gem_path}/gems/**/#{file_path}"]]
       end
       versions = matched_paths.inject([]) do |versions, (root_path, paths)|
         paths.each do |matched_path|
@@ -249,23 +254,26 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
             gem_spec.loaded_from = gemspec_path
             gem_dir = Pathname.new("#{root_path}/#{dir_name}")
             
-            filename = name + File.extname(matched_path)
             relative_file = Pathname.new(matched_path).relative_path_from(gem_dir).to_s           
-            if gem_spec.require_paths.any? { |req| File.join(req, filename) == relative_file }
+            if gem_spec.require_paths.any? { |req| File.join(req, file_path) == relative_file }
               versions << gem_spec
             end
           end
         end
         versions
       end
-      unless versions.empty?
-        spec = versions.max { |a, b| a.version <=> b.version }
-        activate_gem_from_path(spec.loaded_from, spec)
-      end
+      versions.max { |a, b| a.version <=> b.version }
+    end
+    
+    # Find a file in the Gem source index - loads up the full rubygems!
+    def self.find_in_source_index(path)
+      return nil if path == 'Win32API' && !Gem.win_platform?
+      puts "Switching from minigems to full rubygems..." if $MINIGEMS_DEBUG
+      Gem.searcher.find(path)
     end
 
     # Find the best (highest) matching gem version.
-    def self.find(gem, *version_requirements)
+    def self.find_name(gem, *version_requirements)
       version_requirements = Gem::Requirement.default if version_requirements.empty?
       unless gem.respond_to?(:name) && gem.respond_to?(:version_requirements)
         gem = Gem::Dependency.new(gem, version_requirements)
@@ -297,6 +305,12 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
     # Load the full rubygems suite, at which point all minigems logic
     # is being overridden, so all regular methods and classes are available.
     def self.load_full_rubygems!
+      if $MINIGEMS_DEBUG
+        puts 'Loaded full RubyGems'
+        if !caller.first.to_s.match(/`const_missing'$/) && (require_entry = get_require_caller(caller))
+          puts "A gem was possibly implicitly loaded from #{require_entry}"
+        end
+      end
       # Clear out any minigems methods
       class << self
         (MINIGEMS_METHODS - CORE_GEM_METHODS).each do |method_name|
@@ -307,6 +321,13 @@ unless $LOADED_FEATURES.include?("rubygems.rb")
       ::Kernel.module_eval { alias_method :require, :gem_original_require }
       require $LOADED_FEATURES.delete("rubygems.rb")
     end
+    
+    def self.get_require_caller(callstack)
+      require_entry = callstack.find { |c| c =~ /`require'$/ }
+      if require_entry && (idx = callstack.index(require_entry)) && (entry = callstack[idx + 1])
+        entry
+      end
+    end
   
     # Record all minigems methods - except the minigems? predicate method.
     MINIGEMS_METHODS = Gem.methods(false) - ["minigems?"]

data/lib/minigems/core.rb

@@ -0,0 +1,330 @@
+require 'rubygems/rubygems_version'
+require 'rubygems/defaults'
+
+module Gem
+  class LoadError < ::LoadError
+    attr_accessor :name, :version_requirement
+  end
+end
+
+module Gem
+
+  ConfigMap = {} unless defined?(ConfigMap)
+  require 'rbconfig'
+  RbConfig = Config unless defined? ::RbConfig
+
+  ConfigMap.merge!(
+    :BASERUBY => RbConfig::CONFIG["BASERUBY"],
+    :EXEEXT => RbConfig::CONFIG["EXEEXT"],
+    :RUBY_INSTALL_NAME => RbConfig::CONFIG["RUBY_INSTALL_NAME"],
+    :RUBY_SO_NAME => RbConfig::CONFIG["RUBY_SO_NAME"],
+    :arch => RbConfig::CONFIG["arch"],
+    :bindir => RbConfig::CONFIG["bindir"],
+    :datadir => RbConfig::CONFIG["datadir"],
+    :libdir => RbConfig::CONFIG["libdir"],
+    :ruby_install_name => RbConfig::CONFIG["ruby_install_name"],
+    :ruby_version => RbConfig::CONFIG["ruby_version"],
+    :sitedir => RbConfig::CONFIG["sitedir"],
+    :sitelibdir => RbConfig::CONFIG["sitelibdir"],
+    :vendordir => RbConfig::CONFIG["vendordir"] ,
+    :vendorlibdir => RbConfig::CONFIG["vendorlibdir"]
+  )
+
+  DIRECTORIES = %w[cache doc gems specifications] unless defined?(DIRECTORIES)
+
+  RubyGemsPackageVersion = RubyGemsVersion unless defined?(RubyGemsPackageVersion)
+  
+  ##
+  # An Array of Regexps that match windows ruby platforms.
+  
+  unless defined?(WIN_PATTERNS)
+    WIN_PATTERNS = [/bccwin/i, /cygwin/i, /djgpp/i, /mingw/i, /mswin/i, /wince/i]
+  end
+  
+  @@win_platform = nil
+  
+  @platforms = []
+  @ruby = nil
+  
+  ##
+  # Whether minigems is being used or full rubygems has taken over.
+  
+  def self.minigems?
+    not const_defined?(:SourceIndex)
+  end
+  
+  ##
+  # The path to the running Ruby interpreter.
+
+  def self.ruby
+    if @ruby.nil? then
+      @ruby = File.join(ConfigMap[:bindir], ConfigMap[:ruby_install_name])
+      @ruby << ConfigMap[:EXEEXT]
+      # escape string in case path to ruby executable contain spaces.
+      @ruby.sub!(/.*\s.*/m, '"\&"')
+    end
+    @ruby
+  end
+
+  ##
+  # A Gem::Version for the currently running ruby.
+
+  def self.ruby_version
+    return @ruby_version if defined? @ruby_version
+    version = RUBY_VERSION.dup
+    version << ".#{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
+    @ruby_version = Gem::Version.new version
+  end
+  
+  ##
+  # Is this a windows platform?
+
+  def self.win_platform?
+    if @@win_platform.nil? then
+      @@win_platform = !!WIN_PATTERNS.find { |r| RUBY_PLATFORM =~ r }
+    end
+    @@win_platform
+  end
+  
+  ##
+  # The path where gem executables are to be installed.
+
+  def self.bindir(install_dir=Gem.dir)
+    return File.join(install_dir, 'bin') unless
+      install_dir.to_s == Gem.default_dir
+    Gem.default_bindir
+  end
+  
+  ##
+  # The path where gems are to be installed.
+
+  def self.dir
+    @gem_home ||= nil
+    set_home(ENV['GEM_HOME'] || default_dir) unless @gem_home
+    @gem_home
+  end
+  
+  ##
+  # Quietly ensure the named Gem directory contains all the proper
+  # subdirectories.  If we can't create a directory due to a permission
+  # problem, then we will silently continue.
+
+  def self.ensure_gem_subdirectories(gemdir)
+    require 'fileutils'
+
+    Gem::DIRECTORIES.each do |filename|
+      fn = File.join gemdir, filename
+      FileUtils.mkdir_p fn rescue nil unless File.exist? fn
+    end
+  end
+  
+  ##
+  # Finds the user's home directory.
+  #--
+  # Some comments from the ruby-talk list regarding finding the home
+  # directory:
+  #
+  #   I have HOME, USERPROFILE and HOMEDRIVE + HOMEPATH. Ruby seems
+  #   to be depending on HOME in those code samples. I propose that
+  #   it should fallback to USERPROFILE and HOMEDRIVE + HOMEPATH (at
+  #   least on Win32).
+
+  def self.find_home
+    ['HOME', 'USERPROFILE'].each do |homekey|
+      return ENV[homekey] if ENV[homekey]
+    end
+
+    if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
+      return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}"
+    end
+
+    begin
+      File.expand_path("~")
+    rescue
+      File::ALT_SEPARATOR ? "C:/" : "/"
+    end
+  end
+
+  private_class_method :find_home
+  
+  ##
+  # The index to insert activated gem paths into the $LOAD_PATH.
+
+  def self.load_path_insert_index
+    $LOAD_PATH.index ConfigMap[:sitelibdir]
+  end
+  
+  ##
+  # The file name and line number of the caller of the caller of this method.
+
+  def self.location_of_caller
+    file, lineno = caller[1].split(':')
+    lineno = lineno.to_i
+    [file, lineno]
+  end
+
+  private_class_method :location_of_caller
+  
+  ##
+  # The version of the Marshal format for your Ruby.
+
+  def self.marshal_version
+    "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
+  end
+  
+  ##
+  # Array of paths to search for Gems.
+
+  def self.path
+    @gem_path ||= nil
+
+    unless @gem_path then
+      paths = if ENV['GEM_PATH'] then
+                [ENV['GEM_PATH']]
+              else
+                [default_path]
+              end
+
+      if defined?(APPLE_GEM_HOME) and not ENV['GEM_PATH'] then
+        paths << APPLE_GEM_HOME
+      end
+
+      set_paths paths.compact.join(File::PATH_SEPARATOR)
+    end
+
+    @gem_path
+  end
+
+  ##
+  # Set array of platforms this RubyGems supports (primarily for testing).
+
+  def self.platforms=(platforms)
+    @platforms = platforms
+  end
+
+  ##
+  # Array of platforms this RubyGems supports.
+
+  def self.platforms
+    @platforms ||= []
+    if @platforms.empty?
+      @platforms = [Gem::Platform::RUBY, Gem::Platform.local]
+    end
+    @platforms
+  end
+  
+  ##
+  # The directory prefix this RubyGems was installed at.
+
+  def self.prefix
+    prefix = File.dirname File.expand_path(File.join(__FILE__, '..'))
+
+    if File.dirname(prefix) == File.expand_path(ConfigMap[:sitelibdir]) or
+       File.dirname(prefix) == File.expand_path(ConfigMap[:libdir]) or
+       'lib' != File.basename(prefix) then
+      nil
+    else
+      File.dirname prefix
+    end
+  end
+  
+  ##
+  # Set the Gem home directory (as reported by Gem.dir).
+
+  def self.set_home(home)
+    home = home.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+    @gem_home = home
+    ensure_gem_subdirectories(@gem_home)
+  end
+
+  private_class_method :set_home
+
+  ##
+  # Set the Gem search path (as reported by Gem.path).
+
+  def self.set_paths(gpaths)
+    if gpaths
+      @gem_path = gpaths.split(File::PATH_SEPARATOR)
+
+      if File::ALT_SEPARATOR then
+        @gem_path.map! do |path|
+          path.gsub File::ALT_SEPARATOR, File::SEPARATOR
+        end
+      end
+
+      @gem_path << Gem.dir
+    else
+      # TODO: should this be Gem.default_path instead?
+      @gem_path = [Gem.dir]
+    end
+
+    @gem_path.uniq!
+    @gem_path.each do |gp| ensure_gem_subdirectories(gp) end
+  end
+
+  private_class_method :set_paths
+  
+  ##
+  # Glob pattern for require-able path suffixes.
+
+  def self.suffix_pattern
+    @suffix_pattern ||= "{#{suffixes.join(',')}}"
+  end
+
+  ##
+  # Suffixes for require-able paths.
+
+  def self.suffixes
+    ['', '.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar']
+  end
+  
+  ##
+  # Use the +home+ and +paths+ values for Gem.dir and Gem.path.  Used mainly
+  # by the unit tests to provide environment isolation.
+
+  def self.use_paths(home, paths=[])
+    clear_paths
+    set_home(home) if home
+    set_paths(paths.join(File::PATH_SEPARATOR)) if paths
+  end
+
+  ##
+  # The home directory for the user.
+
+  def self.user_home
+    @user_home ||= find_home
+  end
+
+end
+
+module Config
+  # :stopdoc:
+  class << self
+    # Return the path to the data directory associated with the named
+    # package.  If the package is loaded as a gem, return the gem
+    # specific data directory.  Otherwise return a path to the share
+    # area as define by "#{ConfigMap[:datadir]}/#{package_name}".
+    def datadir(package_name)
+      Gem.datadir(package_name) ||
+        File.join(Gem::ConfigMap[:datadir], package_name)
+    end
+  end
+  # :startdoc:
+end
+
+require 'rubygems/exceptions'
+require 'rubygems/version'
+require 'rubygems/requirement'
+require 'rubygems/dependency'
+
+begin
+  require 'rubygems/defaults/operating_system'
+rescue LoadError
+end
+
+if defined?(RUBY_ENGINE) then
+  begin
+    require "rubygems/defaults/#{RUBY_ENGINE}"
+  rescue LoadError
+  end
+end

data/lib/minigems/script_helper.rb

@@ -104,6 +104,8 @@ module Gem
               File.open(install_path, 'w') do |f|
                 f.write minigems_code.sub(placeholder, replacement)
               end
+              minigems_dir = File.join(minigems_path, 'lib', 'minigems')
+              FileUtils.cp_r(minigems_dir, Gem::ConfigMap[:sitelibdir])
               puts "Installed minigems at #{install_path}"
             rescue Errno::EACCES
               puts "Could not install minigems at #{install_path} (try sudo)"
@@ -113,8 +115,9 @@ module Gem
       end
       
       def remove_minigems!
+        minigems_dir = File.join(Gem::ConfigMap[:sitelibdir], 'minigems')
         if File.exists?(install_path = File.join(Gem::ConfigMap[:sitelibdir], 'minigems.rb'))
-          if FileUtils.rm(install_path)
+          if FileUtils.rm(install_path) && FileUtils.rm_rf(minigems_dir)
             puts "Succesfully removed #{install_path}"
             return
           end

data/spec/minigems_spec.rb

@@ -42,10 +42,6 @@ describe Gem::MiniGems do
     Gem.available?("gem_with_lib", ">0.0.2").should be_false
   end
   
-  it "should raise Gem::LoadError if no matching gem was found" do
-    lambda { gem("unknown_gem") }.should raise_error(Gem::LoadError)
-  end
-  
   it "uses 'gem' to setup additional load path entries" do
     gem_lib_path = File.join(@gem_dir, "gems", "gem_with_lib-0.0.2", "lib")
     gem_bin_path = File.join(@gem_dir, "gems", "gem_with_lib-0.0.2", "bin")
@@ -114,6 +110,14 @@ describe Gem::MiniGems do
   # full rubygems library - which cannot really be undone!
   # Comment out the specs above, including before/after setup.
   # 
+  # Also, use the system-installed minigems (for FULL_RUBYGEMS_METHODS):
+  #
+  # require 'minigems'
+  
+  # it "should raise Gem::LoadError if no matching gem was found" do
+  #   lambda { gem("unknown_gem") }.should raise_error(Gem::LoadError)
+  # end
+  
   # it "should load full rubygems if an unimplemented method is called" do
   #   # will only work if pre-installed minigems.rb is used!
   #   # so use: require 'minigems'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: minigems
 version: !ruby/object:Gem::Version 
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors: 
 - Fabien Franzen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-30 00:00:00 +02:00
+date: 2008-10-02 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,7 @@ files:
 - README
 - Rakefile
 - lib/minigems
+- lib/minigems/core.rb
 - lib/minigems/executable_wrapper
 - lib/minigems/script_helper.rb
 - lib/minigems.rb
@@ -79,7 +80,6 @@ files:
 - spec/minigems_spec.rb
 has_rdoc: true
 homepage: http://merbivore.com
-minigems: false
 post_install_message: Run 'minigem' for instructions on how to proceed.
 rdoc_options: []
 
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: merb
-rubygems_version: 1.2.0.1874
+rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
 summary: Lighweight drop-in replacement for rubygems.