minigems 0.9.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Fabien Franzen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,40 @@
+MiniGems
+========
+
+A lightweight drop-in replacement for rubygems to facilitate faster loading of
+gems as well as reducing memory consumption considerably. Depending on the
+amount of gems you have installed about 10-20 MB less RAM will be used, compared
+to the full rubygems library version, which keeps a cache of all gems and files
+referenced by them.
+
+Minigems handles loading of required gems from your scripts. If however, other 
+functionality is needed, the full rubygems library will be loaded automatically 
+to continue normal operation.
+
+You'll need to run 'sudo minigem setup' to get started; this will install
+minigems.rb in your site_ruby directory, which makes it available to all your
+ruby scripts.
+
+MiniGems is enabled on a per-gem basis. To do so, you run 'minigem prepare', for
+example, say we want the binary executables for merb-core (the 'merb' command)
+to use minigems:
+
+sudo minigem prepare merb-core
+
+And to revert back to rubygems:
+
+sudo minigem revert merb-core
+
+To use minigems in your own scripts, use the following construct, instead of the 
+common 'require "rubygems"' statement:
+
+begin 
+  require 'minigems'
+rescue LoadError 
+  require 'rubygems'
+end
+
+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:
+
+http://rubyforge.org/tracker/?func=detail&atid=577&aid=21979&group_id=126

data/Rakefile

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require File.join(File.dirname(__FILE__), 'lib', 'minigems')
+
+##############################################################################
+# Package && release
+##############################################################################
+RUBY_FORGE_PROJECT  = "merb"
+PROJECT_URL         = "http://merbivore.com"
+PROJECT_SUMMARY     = "Lighweight drop-in replacement for rubygems."
+PROJECT_DESCRIPTION = PROJECT_SUMMARY
+
+GEM_AUTHOR = "Fabien Franzen"
+GEM_EMAIL  = "info@atelierfabien.be"
+
+GEM_NAME    = "minigems"
+PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+GEM_VERSION = (Gem::MiniGems::VERSION || "0.9.0") + PKG_BUILD
+
+RELEASE_NAME    = "REL #{GEM_VERSION}"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = RUBY_FORGE_PROJECT
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE"]
+  s.summary = PROJECT_SUMMARY
+  s.description = PROJECT_DESCRIPTION
+  s.author = GEM_AUTHOR
+  s.email = GEM_EMAIL
+  s.homepage = PROJECT_URL
+  s.bindir = "bin"
+  s.executables = %w( minigem )
+  s.require_path = "lib"
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,bin,spec}/**/*")
+  s.post_install_message = "Run 'minigem' for instructions on how to proceed."
+end
+
+def sudo
+  ENV['MERB_SUDO'] ||= "sudo"
+  sudo = windows? ? "" : ENV['MERB_SUDO']
+end
+
+def windows?
+  (PLATFORM =~ /win32|cygwin/) rescue nil
+end
+
+def install_home
+  ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "removes any generated content"
+task :clean do
+  FileUtils.rm_rf "clobber/*"
+  FileUtils.rm_rf "pkg/*"
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc "Install the gem"
+task :install => [:clean, :package] do
+  sh %{#{sudo} gem install #{install_home} pkg/#{GEM_NAME}-#{GEM_VERSION} --no-wrapper --no-update-sources --no-rdoc --no-ri}
+end
+
+namespace :jruby do
+
+  desc "Run :package and install the resulting .gem with jruby"
+  task :install => :package do
+    sh %{#{sudo} jruby -S gem install #{install_home} pkg/#{GEM_NAME}-#{GEM_VERSION}.gem  --no-wrapper --no-rdoc --no-ri}
+  end
+
+end

data/bin/minigem

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'minigems/script_helper'
+
+include Gem::MiniGems::ScriptHelper
+
+if ARGV.empty? || %w[-H --help].detect { |o| ARGV.index(o) }
+  # Show some usage information.
+  program = File.basename($0)
+  puts "Usage:"
+  puts "  #{program} setup"
+  puts "  #{program} prepare GEMNAME [GEMNAME ...]"
+  puts "  #{program} revert  GEMNAME [GEMNAME ...]"
+  puts "  #{program} install GEMNAME [GEMNAME ...] [options] -- --build-flags [options]"
+  puts "  #{program} update  GEMNAME [GEMNAME ...] [options]"
+  puts "  #{program} <command> GEMNAME [GEMNAME ...] [options]"
+  puts "  "
+  puts "Description:"
+  puts "  Manage 'minigems': a lightweight drop-in replacement for the rubygems"
+  puts "  to facilitate faster loading of gems as well as reducing memory"
+  puts "  consumption considerably. Depending on the amount of gems you have"
+  puts "  installed about 10-20 MB less RAM will be used, compared to the full"
+  puts "  rubygems library version, which keeps a cache of all gems and files"
+  puts "  referenced by them."
+  puts "  "
+  puts "  Minigems handles loading of required gems from your scripts. If however,"
+  puts "  other functionality is needed, the full rubygems library will be loaded"
+  puts "  automatically to continue normal operation."
+  puts "  "
+  puts "  To use minigems in your own scripts, use the following construct,"
+  puts "  instead of the common 'require \"rubygems\"' statement:"
+  puts "  "
+  puts "  begin"
+  puts "    require 'minigems'"
+  puts "  rescue LoadError"
+  puts "    require 'rubygems'"
+  puts "  end"
+  puts "  "
+  puts "Options:"
+  puts "  -H, --help      Show this message and quit."
+  puts "  -v, --version   Show the program version number and quit."
+elsif ARGV[0] == 'setup'
+  # Install minigems.rb in the ruby search path.
+  ensure_in_load_path!(true)
+elsif ARGV[0] == 'uninstall'
+  command = ARGV.shift.to_sym # skip command argument
+  # Uninstall minigems.rb from the ruby search path.
+  remove_minigems! if ARGV.empty?
+  # Remove any gems that have been specified.
+  unless ARGV.empty?
+    cmd = Gem::GemRunner.new.run_command(command, ARGV)
+    cmd.get_all_referenced_gem_specs.each do |gemspec|
+      adapt_executables_for(gemspec)
+    end
+  end
+elsif ARGV[0] == 'prepare'
+  # Adapt a gems' executable wrapper to use minigems.
+  ARGV.shift # skip prepare command argument
+  ensure_in_load_path!(ARGV.empty?)
+  ARGV.each do |gem_name|
+    next unless (gem_spec = Gem.source_index.find_name(gem_name).sort_by { |g| g.version }.last)
+    adapt_executables_for(gem_spec)
+  end
+elsif ARGV[0] == 'revert'
+  # Adapt a gems' executable wrapper to use rubygems.
+  ARGV.shift # skip prepare command argument
+  ensure_in_load_path!(ARGV.empty?)
+  ARGV.each do |gem_name|
+    next unless (gem_spec = Gem.source_index.find_name(gem_name).sort_by { |g| g.version }.last)
+    revert_executables_for(gem_spec)
+  end
+elsif ARGV[0] == 'install' || ARGV[0] == 'update'
+  # Install or update a rubygem and prepare it for minigems.
+  command = ARGV.shift.to_sym # skip command argument
+  ensure_in_load_path!(ARGV.empty?)
+  # Remove any gems that have been specified.
+  unless ARGV.empty?
+    cmd = Gem::GemRunner.new.run_command(command, ARGV)
+    cmd.get_all_referenced_gem_specs.each do |gemspec|
+      adapt_executables_for(gemspec)
+    end
+  end
+else
+  # Proxy to rubygems for any other command.
+  #  
+  # We need to preserve the original ARGV to use for passing gem options
+  # to source gems.  If there is a -- in the line, strip all options after
+  # it...its for the source building process.
+  args = !ARGV.include?("--") ? ARGV.clone : ARGV[0...ARGV.index("--")]
+  Gem::GemRunner.new.run(args)
+end

data/lib/minigems.rb

@@ -0,0 +1,267 @@
+module Gem
+  module MiniGems
+    VERSION = "0.9.0"
+    
+    # The next line needs to be kept exactly as shown; it's being replaced
+    # during minigems installation.
+    FULL_RUBYGEMS_METHODS = []
+    
+  end
+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"
+
+  module Kernel
+  
+    def gem(name, *versions)
+      Gem.activate(name, *versions)
+    end
+  
+    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
+        raise load_error
+      end
+    end
+  
+  end
+  
+  module Gem
+  
+    CORE_GEM_METHODS = Gem.methods(false)
+  
+    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 ||= {}
+    end
+  
+    # Refresh the current 'cached' gems - in this case 
+    # just the list of loaded gems.
+    def self.refresh
+      self.loaded_gems.clear
+    end
+  
+    # See if a given gem is available.
+    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?
+    end
+
+    # Activates an installed gem matching +gem+.  The gem must satisfy
+    # +version_requirements+.
+    #
+    # Returns true if the gem is activated, false if it is already
+    # loaded, or an exception otherwise.
+    #
+    # Gem#activate adds the library paths in +gem+ to $LOAD_PATH.  Before a Gem
+    # is activated its required Gems are activated.  If the version information
+    # is omitted, the highest version Gem of the supplied name is loaded.  If a
+    # Gem is not found that meets the version requirements or a required Gem is
+    # not found, a Gem::LoadError is raised.
+    #
+    # 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)
+        # Load and initialize the gemspec
+        gem_spec = Gem::Specification.load(gem_path = match.first)
+        gem_spec.loaded_from = gem_path
+      
+        # Raise an exception if the same spec has already been loaded - except for identical matches
+        if (already_loaded = self.loaded_gems[gem_spec.name]) && gem_spec.full_name != already_loaded
+          raise Gem::Exception, "can't activate #{gem_spec.name}, already activated #{already_loaded}"
+        # If it's an identical match, we're done activating
+        elsif already_loaded
+          return false
+        end
+            
+        # Keep track of loaded gems - by name instead of full specs (memory!)
+        self.loaded_gems[gem_spec.name] = gem_spec.full_name
+      
+        # Load dependent gems first
+        gem_spec.runtime_dependencies.each { |dep_gem| activate(dep_gem) }
+        
+        # bin directory must come before library directories
+        gem_spec.require_paths.unshift(gem_spec.bindir) if gem_spec.bindir
+      
+        # Add gem require paths to $LOAD_PATH
+        gem_spec.require_paths.reverse.each do |require_path|
+          $LOAD_PATH.unshift File.join(gem_spec.full_gem_path, require_path)
+        end
+        return true
+      else
+        unless gem.respond_to?(:name) && gem.respond_to?(:version_requirements)
+          gem = Gem::Dependency.new(gem, version_requirements)
+        end
+        report_activate_error(gem)
+      end
+    end
+    
+    # Helper method to find all current gem paths.
+    #
+    # Find the most recent gem versions' paths just by looking at the gem's 
+    # directory version number. This is faster than parsing gemspec files
+    # at the expense of being less complete when it comes to require paths.
+    # That's why Gem.activate actually parses gemspecs instead of directories.
+    def self.latest_gem_paths
+      lookup = {}
+      gem_path_sets = self.path.map { |path| [path, Dir["#{path}/gems/*"]] }
+      gem_path_sets.each do |root_path, gems|
+        unless gems.empty?
+          gems.each do |gem_path|
+            if matches = File.basename(File.basename(gem_path)).match(/^(.*?)-([\d\.]+)$/)
+              name, version_no = matches.captures[0,2]
+              version = Gem::Version.new(version_no)
+              if !lookup[name] || (lookup[name] && lookup[name][1] < version)
+                lookup[name] = [gem_path, version]
+              end
+            end
+          end
+        end
+      end
+      lookup.collect { |name,(gem_path, version)| gem_path }.sort
+    end
+
+    # Array of paths to search for Gems.
+    def self.path
+      @path ||= begin
+        paths = [ENV['GEM_PATH'] ? ENV['GEM_PATH'] : default_path]
+        paths << APPLE_GEM_HOME if defined?(APPLE_GEM_HOME) && !ENV['GEM_PATH']
+        paths
+      end
+    end
+  
+    # Default gem load path.
+    def self.default_path
+      @default_path ||= if defined? RUBY_FRAMEWORK_VERSION then
+        File.join File.dirname(RbConfig::CONFIG["sitedir"]), 'Gems', 
+          RbConfig::CONFIG["ruby_version"]
+      elsif defined? RUBY_ENGINE then
+        File.join RbConfig::CONFIG["libdir"], RUBY_ENGINE, 'gems', 
+          RbConfig::CONFIG["ruby_version"]
+      else
+        File.join RbConfig::CONFIG["libdir"], 'ruby', 'gems', 
+          RbConfig::CONFIG["ruby_version"]
+      end
+    end
+  
+    # Reset the +path+ value. The next time +path+ is requested, 
+    # the values will be calculated from scratch.
+    def self.clear_paths
+      @path = nil
+    end
+  
+    # Catch calls to full rubygems methods - once accessed
+    # the current Gem methods are overridden.
+    def self.method_missing(m, *args, &blk)
+      if Gem::MiniGems::FULL_RUBYGEMS_METHODS.include?(m.to_s)
+        load_full_rubygems!
+        return send(m, *args, &blk)
+      end
+      super
+    end
+  
+    # Catch references to full rubygems constants - once accessed
+    # the current Gem constants are merged.
+    def self.const_missing(const)
+      load_full_rubygems!
+      if Gem.const_defined?(const)
+        Gem.const_get(const)
+      else
+        super
+      end
+    end
+  
+    protected
+
+    # Find all gem specs for the requested gem.
+    def self.find(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)
+      end
+    
+      gemspec_sets = self.path.map { |path| [path, Dir["#{path}/specifications/#{gem.name}-*.gemspec"]] }
+      versions = gemspec_sets.inject([]) do |versions, (root_path, gems)|
+        unless gems.empty?
+          gems.each do |gemspec_path|
+            if (version_no = gemspec_path[/-([\d\.]+)\.gemspec$/, 1]) &&
+              gem.version_requirements.satisfied_by?(version = Gem::Version.new(version_no))
+              versions << [gemspec_path, version]
+            end
+          end
+        end
+        versions
+      end
+      # Find the best (highest) matching gem version
+      versions.max { |a, b| a.last <=> b.last }
+    end
+  
+    # Report a load error during activation.
+    def self.report_activate_error(gem)
+      error = Gem::LoadError.new("Could not find RubyGem #{gem.name} (#{gem.version_requirements})\n")
+      error.name = gem.name
+      error.version_requirement = gem.version_requirements
+      raise error
+    end
+  
+    # 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!
+      # Clear out any minigems methods
+      class << self
+        (MINIGEMS_METHODS - CORE_GEM_METHODS).each do |method_name|
+          undef_method method_name
+        end
+      end
+      # Re-alias the 'require' method back to its original.
+      ::Kernel.module_eval { alias_method :require, :gem_original_require }
+      require $LOADED_FEATURES.delete("rubygems.rb")
+    end
+  
+    # Record all minigems methods - except the minigems? predicate method.
+    MINIGEMS_METHODS = Gem.methods(false) - ["minigems?"]
+    
+  end
+  
+end

data/lib/minigems/executable_wrapper

@@ -0,0 +1,22 @@
+SHEBANG
+
+# This file was generated by MiniGems (standalone version).
+#
+# The application 'EXECUTABLE_NAME' is installed as part of a gem (GEM_NAME),
+# and this file is here to facilitate running it.
+
+begin
+  require 'GEM_MODE'
+rescue LoadError 
+  require 'rubygems'
+end
+
+version = ">= 0"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem 'GEM_NAME', version
+load 'EXECUTABLE_NAME'

data/lib/minigems/script_helper.rb

@@ -0,0 +1,138 @@
+require 'rubygems/gem_runner'
+require 'rubygems/exceptions'
+require 'rubygems/commands/install_command'
+require 'rubygems/commands/update_command'
+require 'fileutils'
+
+module Gem
+
+  class GemRunner
+    def run_command(command_name, args)
+      args.unshift command_name.to_s
+      do_configuration(args)
+      cmd_manager = @command_manager_class.instance
+      config_args = Gem.configuration[command_name.to_s]
+      config_args = case config_args
+                    when String
+                      config_args.split ' '
+                    else
+                      Array(config_args)
+                    end
+      Command.add_specific_extra_args(command_name, config_args)
+      cmd_manager.run(Gem.configuration.args)
+    rescue Gem::SystemExitException
+      cmd_manager.cmd
+    ensure
+      cmd_manager.cmd
+    end
+  end
+  
+  class Command
+    def get_all_referenced_gem_specs
+      get_all_gem_names.map { |name| Gem.source_index.search(name).last }.compact
+    end
+  end
+  
+  class CommandManager
+    attr_accessor :cmd
+    alias :original_find_command :find_command
+    def find_command(cmd_name)
+      self.cmd = original_find_command(cmd_name)
+      self.cmd
+    end
+  end
+
+  module MiniGems
+    module ScriptHelper
+  
+      def minigems_path
+        @minigems_path ||= begin
+          if (gem_spec = Gem.source_index.find_name('minigems').sort_by { |g| g.version }.last)
+            gem_spec.full_gem_path
+          else
+            raise "Minigems gem not found!"
+          end
+        end
+      end
+  
+      def adapt_executables_for(gemspec)
+        gemspec.executables.each do |executable|
+          next if executable == 'minigem' # better not modify minigem itself
+          if File.exists?(wrapper_path = File.join(Gem.bindir, executable))
+            wrapper_code = interpolate_wrapper(gemspec.name, executable)
+            begin
+              if File.open(wrapper_path, 'w') { |f| f.write(wrapper_code) }
+                puts "Adapted #{wrapper_path} to use minigems instead of rubygems."
+              else
+                puts "Failed to adapt #{wrapper_path} - maybe you need sudo permissions?"
+              end
+            rescue Errno::EACCES => e
+              puts "Failed to adapt #{wrapper_path} - maybe you need sudo permissions?"
+            end  
+          end
+        end
+      end
+      
+      def revert_executables_for(gemspec)
+        gemspec.executables.each do |executable|
+          next if executable == 'minigem' # better not modify minigem itself
+          if File.exists?(wrapper_path = File.join(Gem.bindir, executable))
+            wrapper_code = interpolate_wrapper(gemspec.name, executable, 'rubygems')
+            begin
+              if File.open(wrapper_path, 'w') { |f| f.write(wrapper_code) }
+                puts "Reverted #{wrapper_path} to use rubygems instead of minigems."
+              else
+                puts "Failed to revert #{wrapper_path} - maybe you need sudo permissions?"
+              end
+            rescue Errno::EACCES => e
+              puts "Failed to revert #{wrapper_path} - maybe you need sudo permissions?"
+            end
+          end
+        end      
+      end
+
+      def ensure_in_load_path!(force = false)
+        install_path = File.join(Gem::ConfigMap[:sitelibdir], 'minigems.rb')
+        if force || !File.exists?(install_path)
+          if File.exists?(source_path = File.join(minigems_path, 'lib', 'minigems.rb'))
+            begin
+              minigems_code = File.read(source_path)
+              placeholder = "FULL_RUBYGEMS_METHODS = []"
+              replacement = "FULL_RUBYGEMS_METHODS = %w[\n      "
+              replacement << (Gem.methods - Object.methods).sort.join("\n      ")
+              replacement << "\n    ]"
+              File.open(install_path, 'w') do |f|
+                f.write minigems_code.sub(placeholder, replacement)
+              end
+              puts "Installed minigems at #{install_path}"
+            rescue Errno::EACCES
+              puts "Could not install minigems at #{install_path} (try sudo)"
+            end
+          end
+        end
+      end
+      
+      def remove_minigems!
+        if File.exists?(install_path = File.join(Gem::ConfigMap[:sitelibdir], 'minigems.rb'))
+          if FileUtils.rm(install_path)
+            puts "Succesfully removed #{install_path}"
+            return
+          end
+        end
+      rescue => e
+        puts e.message
+        puts "Could not remove #{install_path} (try sudo)"
+      end
+      
+      def interpolate_wrapper(gem_name, executable_name, mode = 'minigems')
+        @template_code ||= File.read(File.join(minigems_path, 'lib', 'minigems', 'executable_wrapper'))        
+        vars = { 'GEM_NAME' => gem_name, 'EXECUTABLE_NAME' => executable_name }
+        vars['SHEBANG'] = "#!/usr/bin/env " + Gem::ConfigMap[:ruby_install_name]
+        vars['GEM_MODE'] = mode
+        vars.inject(@template_code) { |str,(k,v)| str.gsub(k,v) }
+      end
+  
+    end
+  end
+  
+end

data/spec/fixtures/gems/gem_with_lib-0.0.1/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/fixtures/gems/gem_with_lib-0.0.1/README

@@ -0,0 +1,4 @@
+gem_with_lib
+============
+
+A gem that provides...

data/spec/fixtures/gems/gem_with_lib-0.0.1/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+
+GEM = "gem_with_lib"
+GEM_VERSION = "0.0.1"
+AUTHOR = "Your Name"
+EMAIL = "Your Email"
+HOMEPAGE = "http://example.com"
+SUMMARY = "A gem that provides..."
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/spec/fixtures/gems/gem_with_lib-0.0.1/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/spec/fixtures/gems/gem_with_lib-0.0.1/lib/gem_with_lib.rb

@@ -0,0 +1,5 @@
+module GemWithLib
+  VERSION = "0.0.1"
+  class Awesome
+  end
+end

data/spec/fixtures/gems/gem_with_lib-0.0.2/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/fixtures/gems/gem_with_lib-0.0.2/README

@@ -0,0 +1,4 @@
+gem_with_lib
+============
+
+A gem that provides...

data/spec/fixtures/gems/gem_with_lib-0.0.2/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+
+GEM = "gem_with_lib"
+GEM_VERSION = "0.0.2"
+AUTHOR = "Your Name"
+EMAIL = "Your Email"
+HOMEPAGE = "http://example.com"
+SUMMARY = "A gem that provides..."
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.executables  = %w( gem_with_lib )
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/spec/fixtures/gems/gem_with_lib-0.0.2/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/spec/fixtures/gems/gem_with_lib-0.0.2/bin/gem_with_lib

@@ -0,0 +1 @@
+#!/usr/bin/env ruby

data/spec/fixtures/gems/gem_with_lib-0.0.2/lib/gem_with_lib.rb

@@ -0,0 +1,5 @@
+module GemWithLib
+  VERSION = "0.0.2"
+  class Awesome
+  end
+end

data/spec/fixtures/specifications/gem_with_lib-0.0.1.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name = %q{gem_with_lib}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Your Name"]
+  s.autorequire = %q{gem_with_lib}
+  s.date = %q{2008-08-17}
+  s.description = %q{A gem that provides...}
+  s.email = %q{Your Email}
+  s.extra_rdoc_files = ["README", "LICENSE", "TODO"]
+  s.files = ["LICENSE", "README", "Rakefile", "TODO", "lib/gem_with_lib.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://example.com}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{A gem that provides...}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+    else
+    end
+  else
+  end
+end

data/spec/fixtures/specifications/gem_with_lib-0.0.2.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |s|
+  s.name = %q{gem_with_lib}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Your Name"]
+  s.autorequire = %q{gem_with_lib}
+  s.date = %q{2008-08-19}
+  s.description = %q{A gem that provides...}
+  s.email = %q{Your Email}
+  s.extra_rdoc_files = ["README", "LICENSE", "TODO"]
+  s.files = ["LICENSE", "README", "Rakefile", "TODO", "lib/gem_with_lib.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://example.com}
+  s.executables = %w( gem_with_lib )
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{A gem that provides...}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+    else
+    end
+  else
+  end
+end

data/spec/minigems_spec.rb

@@ -0,0 +1,105 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'minigems')
+
+# We can't use the spec runner, as that will already load or full gems!
+gem "rspec"
+require "spec"
+
+describe Gem::MiniGems do
+  
+  before do
+    # Setup rubygems from our spec fixtures directory
+    Gem.refresh
+    @gem_dir = File.join(File.dirname(__FILE__), "fixtures")
+    Gem.path.replace([@gem_dir])
+  end
+  
+  after do
+    # Remove fixture load paths from $LOAD_PATH for specs
+    $LOAD_PATH.reject! { |path| path.index(@gem_dir) == 0 }
+    $LOADED_FEATURES.delete("gem_with_lib.rb")
+    # Make sure any loaded classes are removed
+    Object.send(:remove_const, "GemWithLib") if Object.const_defined?("GemWithLib")
+    Gem.should be_minigems
+  end
+  
+  it "has a replaceable Gem.path" do
+    Gem.path.replace(["awesome"])
+    Gem.path.should == ["awesome"]
+  end
+    
+  it "loads gems through the Kernel#require method" do
+    require("gem_with_lib").should be_true
+    lambda { GemWithLib::Awesome }.should_not raise_error(NameError)
+    GemWithLib::VERSION.should == "0.0.2"
+  end
+  
+  it "lets you check for gem availability" do
+    Gem.available?("unknown_gem").should be_false
+    Gem.available?("gem_with_lib").should be_true
+    Gem.available?("gem_with_lib", "0.0.1").should be_true
+    Gem.available?("gem_with_lib", "0.0.2").should be_true
+    Gem.available?("gem_with_lib", ">0.0.1").should be_true
+    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")
+    $LOAD_PATH.should_not include(gem_lib_path)
+    gem("gem_with_lib").should be_true
+    $LOAD_PATH.first.should == gem_bin_path
+    $LOAD_PATH.should include(gem_lib_path)
+    $LOAD_PATH.select { |path| path == gem_lib_path }.length.should == 1
+    lambda { GemWithLib::Awesome }.should raise_error(NameError)
+  end
+  
+  it "uses 'gem' to setup additional load path entries (for a specific gem version)" do
+    gem_lib_path = File.join(@gem_dir, "gems", "gem_with_lib-0.0.1", "lib")
+    gem_bin_path = File.join(@gem_dir, "gems", "gem_with_lib-0.0.1", "bin")
+    $LOAD_PATH.should_not include(gem_lib_path)
+    gem("gem_with_lib", "0.0.1").should be_true
+    $LOAD_PATH.first.should == gem_bin_path
+    $LOAD_PATH.should include(gem_lib_path)
+  end
+  
+  it "uses 'gem' to setup additional load path entries (for a gem version requirement)" 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")
+    $LOAD_PATH.should_not include(gem_lib_path)
+    gem("gem_with_lib", ">0.0.1").should be_true
+    $LOAD_PATH.first.should == gem_bin_path
+    $LOAD_PATH.should include(gem_lib_path)
+  end
+  
+  it "correctly requires a file from the load path" do
+    gem("gem_with_lib").should be_true
+    require("gem_with_lib").should be_true
+    lambda { GemWithLib::Awesome }.should_not raise_error(NameError)
+    GemWithLib::VERSION.should == "0.0.2"
+  end
+  
+  it "returns all the latest gem versions' paths" do
+    Gem.latest_gem_paths.should == [File.join(@gem_dir, "gems", "gem_with_lib-0.0.2")]
+  end
+  
+  # The following specs can only be run in isolation as they load up the
+  # full rubygems library - which cannot really be undone!
+  # Comment out the specs above, including before/after setup.
+  
+  # it "should load full rubygems if an unimplemented method is called" do
+  #   Gem.should be_minigems
+  #   lambda { Gem.source_index }.should_not raise_error(NoMethodError)
+  #   Gem.should_not be_minigems
+  # end
+  
+  # it "should load full rubygems if a missing Gem constant is referenced" do
+  #   Gem.should be_minigems
+  #   lambda { Gem::Builder }.should_not raise_error(NameError)
+  #   Gem.should_not be_minigems
+  # end
+  
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: minigems
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Fabien Franzen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-19 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Lighweight drop-in replacement for rubygems.
+email: info@atelierfabien.be
+executables: 
+- minigem
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/minigems
+- lib/minigems/executable_wrapper
+- lib/minigems/script_helper.rb
+- lib/minigems.rb
+- bin/minigem
+- spec/fixtures
+- spec/fixtures/cache
+- spec/fixtures/cache/gem_with_lib-0.0.1.gem
+- spec/fixtures/cache/gem_with_lib-0.0.2.gem
+- spec/fixtures/gems
+- spec/fixtures/gems/gem_with_lib-0.0.1
+- spec/fixtures/gems/gem_with_lib-0.0.1/lib
+- spec/fixtures/gems/gem_with_lib-0.0.1/lib/gem_with_lib.rb
+- spec/fixtures/gems/gem_with_lib-0.0.1/LICENSE
+- spec/fixtures/gems/gem_with_lib-0.0.1/Rakefile
+- spec/fixtures/gems/gem_with_lib-0.0.1/README
+- spec/fixtures/gems/gem_with_lib-0.0.1/TODO
+- spec/fixtures/gems/gem_with_lib-0.0.2
+- spec/fixtures/gems/gem_with_lib-0.0.2/bin
+- spec/fixtures/gems/gem_with_lib-0.0.2/bin/gem_with_lib
+- spec/fixtures/gems/gem_with_lib-0.0.2/lib
+- spec/fixtures/gems/gem_with_lib-0.0.2/lib/gem_with_lib.rb
+- spec/fixtures/gems/gem_with_lib-0.0.2/LICENSE
+- spec/fixtures/gems/gem_with_lib-0.0.2/Rakefile
+- spec/fixtures/gems/gem_with_lib-0.0.2/README
+- spec/fixtures/gems/gem_with_lib-0.0.2/TODO
+- spec/fixtures/specifications
+- spec/fixtures/specifications/gem_with_lib-0.0.1.gemspec
+- spec/fixtures/specifications/gem_with_lib-0.0.2.gemspec
+- 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: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: merb
+rubygems_version: 1.2.0.1874
+signing_key: 
+specification_version: 2
+summary: Lighweight drop-in replacement for rubygems.
+test_files: []
+