bundler08 0.8.2

data/lib/bundler08/runtime.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "runtime", "dsl")
+require File.join(File.dirname(__FILE__), "runtime", "dependency")

data/lib/bundler08/source.rb

@@ -0,0 +1,365 @@
+module Bundler
+  class DirectorySourceError < StandardError; end
+  class GitSourceError < StandardError ; end
+  # Represents a source of rubygems. Initially, this is only gem repositories, but
+  # eventually, this will be git, svn, HTTP
+  class Source
+    attr_reader   :bundle
+
+    def initialize(bundle, options)
+      @bundle = bundle
+    end
+
+  private
+
+    def process_source_gems(gems)
+      new_gems = Hash.new { |h,k| h[k] = [] }
+      gems.values.each do |spec|
+        spec.source = self
+        new_gems[spec.name] << spec
+      end
+      new_gems
+    end
+  end
+
+  class GemSource < Source
+    attr_reader :uri
+
+    def initialize(bundle, options)
+      super
+      @uri = options[:uri]
+      @uri = URI.parse(@uri) unless @uri.is_a?(URI)
+      raise ArgumentError, "The source must be an absolute URI" unless @uri.absolute?
+    end
+
+    def local?
+      false
+    end
+
+    def gems
+      @specs ||= fetch_specs
+    end
+
+    def ==(other)
+      uri == other.uri
+    end
+
+    def to_s
+      @uri.to_s
+    end
+
+    class RubygemsRetardation < StandardError; end
+
+    def download(spec)
+      Bundler.logger.info "Downloading #{spec.full_name}.gem"
+
+      destination = bundle.gem_path
+
+      unless destination.writable?
+        raise RubygemsRetardation, "destination: #{destination} is not writable"
+      end
+
+      # Download the gem
+      Gem::RemoteFetcher.fetcher.download(spec, uri, destination)
+
+      # Re-read the gemspec from the downloaded gem to correct
+      # any errors that were present in the Rubyforge specification.
+      new_spec = Gem::Format.from_file_by_path(destination.join('cache', "#{spec.full_name}.gem")).spec
+      spec.__swap__(new_spec)
+    end
+
+  private
+
+    def fetch_specs
+      Bundler.logger.info "Updating source: #{to_s}"
+      build_gem_index(fetch_main_specs + fetch_prerelease_specs)
+    end
+
+    def build_gem_index(index)
+      gems = Hash.new { |h,k| h[k] = [] }
+      index.each do |name, version, platform|
+        spec = RemoteSpecification.new(name, version, platform, @uri)
+        spec.source = self
+        gems[spec.name] << spec if Gem::Platform.match(spec.platform)
+      end
+      gems
+    end
+
+    def fetch_main_specs
+      Marshal.load(Gem::RemoteFetcher.fetcher.fetch_path("#{uri}/specs.4.8.gz"))
+    rescue Gem::RemoteFetcher::FetchError => e
+      raise ArgumentError, "#{to_s} is not a valid source: #{e.message}"
+    end
+
+    def fetch_prerelease_specs
+      Marshal.load(Gem::RemoteFetcher.fetcher.fetch_path("#{uri}/prerelease_specs.4.8.gz"))
+    rescue Gem::RemoteFetcher::FetchError
+      Bundler.logger.warn "Source '#{uri}' does not support prerelease gems"
+      []
+    end
+  end
+
+  class SystemGemSource < Source
+
+    def self.instance
+      @instance
+    end
+
+    def self.new(*args)
+      @instance ||= super
+    end
+
+    def initialize(bundle, options = {})
+      super
+      @source = Gem::SourceIndex.from_installed_gems
+    end
+
+    def local?
+      false
+    end
+
+    def gems
+      @gems ||= process_source_gems(@source.gems)
+    end
+
+    def ==(other)
+      other.is_a?(SystemGemSource)
+    end
+
+    def to_s
+      "system"
+    end
+
+    def download(spec)
+      gemfile = Pathname.new(spec.loaded_from)
+      gemfile = gemfile.dirname.join('..', 'cache', "#{spec.full_name}.gem")
+      bundle.cache(gemfile)
+    end
+
+  private
+
+  end
+
+  class GemDirectorySource < Source
+    attr_reader :location
+
+    def initialize(bundle, options)
+      super
+      @location = options[:location]
+    end
+
+    def local?
+      true
+    end
+
+    def gems
+      @specs ||= fetch_specs
+    end
+
+    def ==(other)
+      location == other.location
+    end
+
+    def to_s
+      location.to_s
+    end
+
+    def download(spec)
+      # raise NotImplementedError
+    end
+
+  private
+
+    def fetch_specs
+      specs = Hash.new { |h,k| h[k] = [] }
+
+      Dir["#{@location}/*.gem"].each do |gemfile|
+        spec = Gem::Format.from_file_by_path(gemfile).spec
+        spec.source = self
+        specs[spec.name] << spec
+      end
+
+      specs
+    end
+  end
+
+  class DirectorySource < Source
+    attr_reader :location, :specs, :required_specs
+
+    def initialize(bundle, options)
+      super
+      if options[:location]
+        @location = Pathname.new(options[:location]).expand_path
+      end
+      @glob           = options[:glob] || "**/*.gemspec"
+      @specs          = {}
+      @required_specs = []
+    end
+
+    def add_spec(path, name, version, require_paths = %w(lib))
+      raise DirectorySourceError, "already have a gem defined for '#{path}'" if @specs[path.to_s]
+      @specs[path.to_s] = Gem::Specification.new do |s|
+        s.name     = name
+        s.version  = Gem::Version.new(version)
+      end
+    end
+
+    def local?
+      true
+    end
+
+    def gems
+      @gems ||= begin
+        # Locate all gemspecs from the directory
+        specs = locate_gemspecs
+        specs = merge_defined_specs(specs)
+
+        required_specs.each do |required|
+          unless specs.any? {|k,v| v.name == required }
+            raise DirectorySourceError, "No gemspec for '#{required}' was found in" \
+              " '#{location}'. Please explicitly specify a version."
+          end
+        end
+
+        process_source_gems(specs)
+      end
+    end
+
+    def locate_gemspecs
+      Dir["#{location}/#{@glob}"].inject({}) do |specs, file|
+        file = Pathname.new(file)
+        if spec = eval(File.read(file)) # and validate_gemspec(file.dirname, spec)
+          spec.location = file.dirname.expand_path
+          specs[spec.full_name] = spec
+        end
+        specs
+      end
+    end
+
+    def merge_defined_specs(specs)
+      @specs.each do |path, spec|
+        # Set the spec location
+        spec.location = "#{location}/#{path}"
+
+        if existing = specs.values.find { |s| s.name == spec.name }
+          if existing.version != spec.version
+            raise DirectorySourceError, "The version you specified for #{spec.name}" \
+              " is #{spec.version}. The gemspec is #{existing.version}."
+          # Not sure if this is needed
+          # ====
+          # elsif File.expand_path(existing.location) != File.expand_path(spec.location)
+          #   raise DirectorySourceError, "The location you specified for #{spec.name}" \
+          #     " is '#{spec.location}'. The gemspec was found at '#{existing.location}'."
+          end
+        # elsif !validate_gemspec(spec.location, spec)
+        #   raise "Your gem definition is not valid: #{spec}"
+        else
+          specs[spec.full_name] = spec
+        end
+      end
+      specs
+    end
+
+    def validate_gemspec(path, spec)
+      path = Pathname.new(path)
+      msg  = "Gemspec for #{spec.name} (#{spec.version}) is invalid:"
+      # Check the require_paths
+      (spec.require_paths || []).each do |require_path|
+        unless path.join(require_path).directory?
+          Bundler.logger.warn "#{msg} Missing require path: '#{require_path}'"
+          return false
+        end
+      end
+
+      # Check the executables
+      (spec.executables || []).each do |exec|
+        unless path.join(spec.bindir, exec).file?
+          Bundler.logger.warn "#{msg} Missing executable: '#{File.join(spec.bindir, exec)}'"
+          return false
+        end
+      end
+
+      true
+    end
+
+    def ==(other)
+      # TMP HAX
+      other.is_a?(DirectorySource)
+    end
+
+    def to_s
+      "directory: '#{location}'"
+    end
+
+    def download(spec)
+      # Nothing needed here
+    end
+  end
+
+  class GitSource < DirectorySource
+    attr_reader :ref, :uri, :branch
+
+    def initialize(bundle, options)
+      super
+      @uri = options[:uri]
+      @branch = options[:branch] || 'master'
+      @ref = options[:ref] || "origin/#{@branch}"
+    end
+
+    def local?
+      raise SourceNotCached, "Git repository '#{@uri}' has not been cloned yet" unless location.directory?
+      super
+    end
+
+    def location
+      # TMP HAX to get the *.gemspec reading to work
+      bundle.gem_path.join('dirs', File.basename(@uri, '.git'))
+    end
+
+    def gems
+      update if Bundler.remote?
+      checkout if Bundler.writable?
+      super
+    end
+
+    def download(spec)
+      # Nothing needed here
+    end
+
+    def to_s
+      "git: #{uri}"
+    end
+
+    private
+      def update
+        if location.directory?
+          fetch if current_revision != revision_for_ref
+        else
+          clone
+        end
+      end
+
+      def fetch
+        Bundler.logger.info "Fetching git repository at: #{@uri}"
+        Dir.chdir(location) { `git fetch origin` }
+      end
+
+      def clone
+        Bundler.logger.info "Cloning git repository at: #{@uri}"
+        FileUtils.mkdir_p(location.dirname)
+        `git clone #{@uri} #{location} --no-hardlinks`
+      end
+
+      def current_revision
+        Dir.chdir(location) { `git rev-parse HEAD`.strip }
+      end
+
+      def revision_for_ref
+        Dir.chdir(location) { `git rev-parse #{@ref}`.strip }
+      end
+
+      def checkout
+        Dir.chdir(location) { `git checkout --quiet #{@ref}` }
+      end
+  end
+end

data/lib/bundler08/templates/Gemfile

@@ -0,0 +1,72 @@
+# Specify a dependency on rails. When the bundler downloads gems,
+# it will download rails as well as all of rails' dependencies (such as
+# activerecord, actionpack, etc...)
+#
+# At least one dependency must be specified
+#gem "rails"
+
+# Specify a dependency on rack v.1.0.0. The version is optional. If present,
+# it can be specified the same way as with rubygems' #gem method.
+#gem "rack", "1.0.0"
+
+# Specify a dependency rspec, but only require that gem in the "testing"
+# environment. :except is also a valid option to specify environment
+# restrictions.
+#gem "rspec", :only => :testing
+
+# Specify a dependency, but specify that it is already present and expanded
+# at vendor/rspec. Bundler will treat rspec as though it was the rspec gem
+# for the purpose of gem resolution: if another gem depends on a version
+# of rspec satisfied by "1.1.6", it will be used.
+#
+# If a gemspec is found in the directory, it will be used to specify load
+# paths and supply additional dependencies.
+#
+# Bundler will also recursively search for *.gemspec, and assume that
+# gemspecs it finds represent gems that are rooted in the same directory
+# the gemspec is found in.
+#gem "rspec", "1.1.6", :vendored_at => "vendor/rspec"
+
+# You can also control what will happen when you run Bundler.require_env
+# by using the :require_as option, as per the next two examples.
+
+# Don't auto-require this gem.
+#gem "rspec-rails", "1.2.9", :require_as => nil
+
+# Require something other than the default.
+#gem "yajl-ruby", "0.6.7", :require_as => "yajl/json_gem"
+
+# Works exactly like :vendored_at, but first downloads the repo from
+# git and handles stashing the files for you. As with :vendored_at,
+# Bundler will automatically use *.gemspec files in the root or anywhere
+# in the repository.
+#gem "rails", "3.0.pre", :git => "git://github.com/rails/rails.git"
+
+# Add http://gems.github.com as a source that the bundler will use
+# to find gems listed in the manifest. By default,
+# http://gems.rubyforge.org is already added to the list.
+#
+# This is an optional setting.
+#source "http://gems.github.com"
+
+# Specify where the bundled gems should be stashed. This directory will
+# be a gem repository where all gems are downloaded to and installed to.
+#
+# This is an optional setting.
+# The default is: vendor/gems
+#bundle_path "my/bundled/gems"
+
+# Specify where gem executables should be copied to.
+#
+# This is an optional setting.
+# The default is: bin
+#bin_path "my/executables"
+
+# Specify that rubygems should be completely disabled. This means that it
+# will be impossible to require it and that available gems will be
+# limited exclusively to gems that have been bundled.
+#
+# The default is to automatically require rubygems. There is also a
+# `disable_system_gems` option that will limit available rubygems to
+# the ones that have been bundled.
+#disable_rubygems

data/lib/bundler08/templates/app_script.erb

@@ -0,0 +1,3 @@
+<%= shebang bin_file_name %>
+require File.expand_path(File.join(File.dirname(__FILE__), "<%= path.join("environment").relative_path_from(Pathname.new(bin_dir)) %>"))
+load File.expand_path(File.join(File.dirname(__FILE__), "<%= path.join("gems", @spec.full_name, @spec.bindir, bin_file_name).relative_path_from(Pathname.new(bin_dir)) %>"))

data/lib/bundler08/templates/environment.erb

@@ -0,0 +1,156 @@
+# DO NOT MODIFY THIS FILE
+module Bundler
+ file = File.expand_path(__FILE__)
+ dir = File.dirname(file)
+
+<% unless system_gems? -%>
+  ENV["GEM_HOME"] = dir
+  ENV["GEM_PATH"] = dir
+
+  # handle 1.9 where system gems are always on the load path
+  if defined?(::Gem)
+    $LOAD_PATH.reject! do |p|
+      p != File.dirname(__FILE__) &&
+        Gem.path.any? { |gp| p.include?(gp) }
+    end
+  end
+
+<% end -%>
+  ENV["PATH"]     = "#{dir}/<%= bindir %><%= File::PATH_SEPARATOR %>#{ENV["PATH"]}"
+  ENV["RUBYOPT"]  = "-r#{file} #{ENV["RUBYOPT"]}"
+
+<% load_paths.each do |load_path| -%>
+  $LOAD_PATH.unshift File.expand_path("#{dir}/<%= load_path %>")
+<% end -%>
+
+  @gemfile = "#{dir}/<%= filename %>"
+
+<% if rubygems? -%>
+  require "rubygems" unless respond_to?(:gem) # 1.9 already has RubyGems loaded
+
+  @bundled_specs = {}
+<% specs.each do |spec| -%>
+<% if spec.no_bundle? -%>
+  gem "<%= spec.name %>", "<%= spec.version %>"
+<% else -%>
+<% path = spec_file_for(spec) -%>
+  @bundled_specs["<%= spec.name %>"] = eval(File.read("#{dir}/<%= path %>"))
+  @bundled_specs["<%= spec.name %>"].loaded_from = "#{dir}/<%= path %>"
+<% end -%>
+<% end -%>
+
+  def self.add_specs_to_loaded_specs
+    Gem.loaded_specs.merge! @bundled_specs
+  end
+
+  def self.add_specs_to_index
+    @bundled_specs.each do |name, spec|
+      Gem.source_index.add_spec spec
+    end
+  end
+
+  add_specs_to_loaded_specs
+  add_specs_to_index
+<% end -%>
+
+  def self.require_env(env = nil)
+    context = Class.new do
+      def initialize(env) @env = env && env.to_s ; end
+      def method_missing(*) ; yield if block_given? ; end
+      def only(*env)
+        old, @only = @only, _combine_only(env.flatten)
+        yield
+        @only = old
+      end
+      def except(*env)
+        old, @except = @except, _combine_except(env.flatten)
+        yield
+        @except = old
+      end
+      def gem(name, *args)
+        opt = args.last.is_a?(Hash) ? args.pop : {}
+        only = _combine_only(opt[:only] || opt["only"])
+        except = _combine_except(opt[:except] || opt["except"])
+        files = opt[:require_as] || opt["require_as"] || name
+        files = [files] unless files.respond_to?(:each)
+
+        return unless !only || only.any? {|e| e == @env }
+        return if except && except.any? {|e| e == @env }
+
+        if files = opt[:require_as] || opt["require_as"]
+          files = Array(files)
+          files.each { |f| require f }
+        else
+          begin
+            require name
+          rescue LoadError
+            # Do nothing
+          end
+        end
+        yield if block_given?
+        true
+      end
+      private
+      def _combine_only(only)
+        return @only unless only
+        only = [only].flatten.compact.uniq.map { |o| o.to_s }
+        only &= @only if @only
+        only
+      end
+      def _combine_except(except)
+        return @except unless except
+        except = [except].flatten.compact.uniq.map { |o| o.to_s }
+        except |= @except if @except
+        except
+      end
+    end
+    context.new(env && env.to_s).instance_eval(File.read(@gemfile), @gemfile, 1)
+  end
+end
+
+<% if rubygems? -%>
+module Gem
+  @loaded_stacks = Hash.new { |h,k| h[k] = [] }
+
+  def source_index.refresh!
+    super
+    Bundler.add_specs_to_index
+  end
+end
+<% else -%>
+$" << "rubygems.rb"
+
+module Kernel
+  def gem(*)
+    # Silently ignore calls to gem, since, in theory, everything
+    # is activated correctly already.
+  end
+end
+
+# Define all the Gem errors for gems that reference them.
+module Gem
+  def self.ruby ; <%= Gem.ruby.inspect %> ; end
+  def self.dir ; @dir ||= File.dirname(File.expand_path(__FILE__)) ; end
+  class << self ; alias default_dir dir; alias path dir ; end
+  class LoadError < ::LoadError; end
+  class Exception < RuntimeError; end
+  class CommandLineError < Exception; end
+  class DependencyError < Exception; end
+  class DependencyRemovalException < Exception; end
+  class GemNotInHomeException < Exception ; end
+  class DocumentError < Exception; end
+  class EndOfYAMLException < Exception; end
+  class FilePermissionError < Exception; end
+  class FormatException < Exception; end
+  class GemNotFoundException < Exception; end
+  class InstallError < Exception; end
+  class InvalidSpecificationException < Exception; end
+  class OperationNotSupportedError < Exception; end
+  class RemoteError < Exception; end
+  class RemoteInstallationCancelled < Exception; end
+  class RemoteInstallationSkipped < Exception; end
+  class RemoteSourceException < Exception; end
+  class VerificationError < Exception; end
+  class SystemExitException < SystemExit; end
+end
+<% end -%>