peritor-bundler 0.7.0

data/lib/bundler/runtime.rb

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

data/lib/bundler/source.rb

@@ -0,0 +1,327 @@
+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_accessor :repository, :local
+
+    def initialize(options) ; 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(options)
+      @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 can_be_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 = repository.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}"
+
+      fetcher = Gem::RemoteFetcher.fetcher
+      main_index = fetcher.fetch_path("#{uri}/specs.4.8.gz")
+      begin
+        prerelease_index = fetcher.fetch_path("#{uri}/prerelease_specs.4.8.gz")
+        index = Marshal.load(main_index) + Marshal.load(prerelease_index)
+      rescue Gem::RemoteFetcher::FetchError
+        Bundler.logger.warn "Source '#{uri}' does not support prerelease gems"
+        index = Marshal.load(main_index)
+      end
+
+      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
+    rescue Gem::RemoteFetcher::FetchError => e
+      raise ArgumentError, "#{to_s} is not a valid source: #{e.message}"
+    end
+  end
+
+  class SystemGemSource < Source
+
+    def self.instance
+      @instance ||= new({})
+    end
+
+    def initialize(options)
+      @source = Gem::SourceIndex.from_installed_gems
+    end
+
+    def can_be_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")
+      repository.cache(gemfile)
+    end
+
+  private
+
+  end
+
+  class GemDirectorySource < Source
+    attr_reader :location
+
+    def initialize(options)
+      @location = options[:location]
+    end
+
+    def can_be_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(options)
+      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 can_be_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
+      "#{@name} (#{@version}) Located at: '#{location}'"
+    end
+
+    def download(spec)
+      # Nothing needed here
+    end
+  end
+
+  class GitSource < DirectorySource
+    attr_reader :ref, :uri, :branch
+
+    def initialize(options)
+      super
+      @uri = options[:uri]
+      @ref = options[:ref]
+      @branch = options[:branch]
+      @shallow = options[:shallow] ? '--depth=1' : ''
+    end
+
+    def location
+      # TMP HAX to get the *.gemspec reading to work
+      repository.path.join('dirs', File.basename(@uri, '.git'))
+    end
+
+    def gems
+      unless location.directory?
+        # Raise an error if the source should run in local mode,
+        # but it has not been cached yet.
+        if local
+          raise SourceNotCached, "Git repository '#{@uri}' has not been cloned yet"
+        end
+
+        FileUtils.mkdir_p(location.dirname)
+
+        Bundler.logger.info "Cloning git repository at: #{@uri}"
+        `git clone #{@shallow} #{@uri} #{location} --no-hardlinks`
+
+        if @ref
+          Dir.chdir(location) { `git checkout --quiet #{@ref}` }
+        elsif @branch && @branch != "master"
+          Dir.chdir(location) { `git checkout --quiet origin/#{@branch}` }
+        end
+      end
+      super
+    end
+
+    def download(spec)
+      # Nothing needed here
+    end
+  end
+end

data/lib/bundler/templates/app_script.erb

@@ -0,0 +1,3 @@
+<%= shebang bin_file_name %>
+require File.join(File.dirname(__FILE__), "<%= path.join("environment").relative_path_from(Pathname.new(bin_dir)) %>")
+load 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/bundler/templates/environment.erb

@@ -0,0 +1,145 @@
+# DO NOT MODIFY THIS FILE
+module Bundler
+ file = File.expand_path(__FILE__)
+ dir = File.dirname(file)
+
+<% unless options[:system_gems] -%>
+  ENV["GEM_HOME"] = dir
+  ENV["GEM_PATH"] = dir
+<% end -%>
+  ENV["PATH"]     = "#{dir}/<%= bindir %>:#{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 options[:rubygems] -%>
+  require "rubygems"
+
+  @bundled_specs = {}
+<% specs.each do |spec| -%>
+<% if options[:no_bundle].include?(spec.name) -%>
+  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 options[: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
+  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 -%>