gemrage 0.0.0

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler/installer.rb

@@ -0,0 +1,84 @@
+require 'erb'
+require 'rubygems/dependency_installer'
+
+module Bundler
+  class Installer < Environment
+    def self.install(root, definition, options = {})
+      installer = new(root, definition)
+      installer.run(options)
+      installer
+    end
+
+    def run(options)
+      if Bundler.settings[:frozen]
+        @definition.ensure_equivalent_gemfile_and_lockfile
+      end
+
+      if dependencies.empty?
+        Bundler.ui.warn "The Gemfile specifies no dependencies"
+        return
+      end
+
+      if Bundler.default_lockfile.exist? && !options["update"]
+        begin
+          tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
+          local = true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
+        rescue BundlerError
+        end
+      end
+
+      # Since we are installing, we can resolve the definition
+      # using remote specs
+      unless local
+        options["local"] ?
+          @definition.resolve_with_cache! :
+          @definition.resolve_remotely!
+      end
+
+      # Ensure that BUNDLE_PATH exists
+      Bundler.mkdir_p(Bundler.bundle_path) unless File.exist?(Bundler.bundle_path)
+
+      # Must install gems in the order that the resolver provides
+      # as dependencies might actually affect the installation of
+      # the gem.
+      specs.each do |spec|
+        spec.source.fetch(spec) if spec.source.respond_to?(:fetch)
+
+        # unless requested_specs.include?(spec)
+        #   Bundler.ui.debug "  * Not in requested group; skipping."
+        #   next
+        # end
+
+        begin
+          old_args = Gem::Command.build_args
+          Gem::Command.build_args = [Bundler.settings["build.#{spec.name}"]]
+          spec.source.install(spec)
+        ensure
+          Gem::Command.build_args = old_args
+        end
+
+        Bundler.ui.info ""
+        generate_bundler_executable_stubs(spec) if Bundler.settings[:bin]
+        FileUtils.rm_rf(Bundler.tmp)
+      end
+
+      lock
+    end
+
+  private
+
+    def generate_bundler_executable_stubs(spec)
+      bin_path = Bundler.bin_path
+      template = File.read(File.expand_path('../templates/Executable', __FILE__))
+      relative_gemfile_path = Bundler.default_gemfile.relative_path_from(bin_path)
+      ruby_command = Thor::Util.ruby_command
+
+      spec.executables.each do |executable|
+        next if executable == "bundle"
+        File.open "#{bin_path}/#{executable}", 'w', 0755 do |f|
+          f.puts ERB.new(template, nil, '-').result(binding)
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler/lazy_specification.rb

@@ -0,0 +1,71 @@
+require "uri"
+require "rubygems/spec_fetcher"
+
+module Bundler
+  class LazySpecification
+    include MatchPlatform
+
+    attr_reader :name, :version, :dependencies, :platform
+    attr_accessor :source
+
+    def initialize(name, version, platform, source = nil)
+      @name          = name
+      @version       = version
+      @dependencies  = []
+      @platform      = platform
+      @source        = source
+      @specification = nil
+    end
+
+    def full_name
+      if platform == Gem::Platform::RUBY or platform.nil? then
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    def satisfies?(dependency)
+      @name == dependency.name && dependency.requirement.satisfied_by?(Gem::Version.new(@version))
+    end
+
+    def to_lock
+      if platform == Gem::Platform::RUBY or platform.nil?
+        out = "    #{name} (#{version})\n"
+      else
+        out = "    #{name} (#{version}-#{platform})\n"
+      end
+
+      dependencies.sort_by {|d| d.name }.each do |dep|
+        next if dep.type == :development
+        out << "    #{dep.to_lock}\n"
+      end
+
+      out
+    end
+
+    def __materialize__
+      @specification = source.specs.search(Gem::Dependency.new(name, version)).last
+    end
+
+    def respond_to?(*args)
+      super || @specification.respond_to?(*args)
+    end
+
+    def to_s
+      "#{name} (#{version})"
+    end
+
+  private
+
+    def method_missing(method, *args, &blk)
+      if Gem::Specification.new.respond_to?(method)
+        raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
+        @specification.send(method, *args, &blk)
+      else
+        super
+      end
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler/lockfile_parser.rb

@@ -0,0 +1,108 @@
+require "strscan"
+
+module Bundler
+  class LockfileParser
+    attr_reader :sources, :dependencies, :specs, :platforms
+
+    def initialize(lockfile)
+      @platforms    = []
+      @sources      = []
+      @dependencies = []
+      @specs        = []
+      @state        = :source
+
+      lockfile.split(/(\r?\n)+/).each do |line|
+        if line == "DEPENDENCIES"
+          @state = :dependency
+        elsif line == "PLATFORMS"
+          @state = :platform
+        else
+          send("parse_#{@state}", line)
+        end
+      end
+    end
+
+  private
+
+    TYPES = {
+      "GIT"  => Bundler::Source::Git,
+      "GEM"  => Bundler::Source::Rubygems,
+      "PATH" => Bundler::Source::Path
+    }
+
+    def parse_source(line)
+      case line
+      when "GIT", "GEM", "PATH"
+        @current_source = nil
+        @opts, @type = {}, line
+      when "  specs:"
+        @current_source = TYPES[@type].from_lock(@opts)
+        @sources << @current_source
+      when /^  ([a-z]+): (.*)$/i
+        value = $2
+        value = true if value == "true"
+        value = false if value == "false"
+
+        key = $1
+
+        if @opts[key]
+          @opts[key] = Array(@opts[key])
+          @opts[key] << value
+        else
+          @opts[key] = value
+        end
+      else
+        parse_spec(line)
+      end
+    end
+
+    NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
+
+    def parse_dependency(line)
+      if line =~ %r{^ {2}#{NAME_VERSION}(!)?$}
+        name, version, pinned = $1, $2, $4
+        version = version.split(",").map { |d| d.strip } if version
+
+        dep = Bundler::Dependency.new(name, version)
+
+        if pinned && dep.name != 'bundler'
+          spec = @specs.find { |s| s.name == dep.name }
+          dep.source = spec.source if spec
+
+          # Path sources need to know what the default name / version
+          # to use in the case that there are no gemspecs present. A fake
+          # gemspec is created based on the version set on the dependency
+          # TODO: Use the version from the spec instead of from the dependency
+          if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Bundler::Source::Path)
+            dep.source.name    = name
+            dep.source.version = $1
+          end
+        end
+
+        @dependencies << dep
+      end
+    end
+
+    def parse_spec(line)
+      if line =~ %r{^ {4}#{NAME_VERSION}$}
+        name, version = $1, Gem::Version.new($2)
+        platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
+        @current_spec = LazySpecification.new(name, version, platform)
+        @current_spec.source = @current_source
+        @specs << @current_spec
+      elsif line =~ %r{^ {6}#{NAME_VERSION}$}
+        name, version = $1, $2
+        version = version.split(',').map { |d| d.strip } if version
+        dep = Gem::Dependency.new(name, version)
+        @current_spec.dependencies << dep
+      end
+    end
+
+    def parse_platform(line)
+      if line =~ /^  (.*)$/
+        @platforms << Gem::Platform.new($1)
+      end
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/bundler-1.0.3/lib/bundler/remote_specification.rb

@@ -0,0 +1,59 @@
+require "uri"
+require "rubygems/spec_fetcher"
+
+module Bundler
+  # Represents a lazily loaded gem specification, where the full specification
+  # is on the source server in rubygems' "quick" index. The proxy object is to
+  # be seeded with what we're given from the source's abbreviated index - the
+  # full specification will only be fetched when necesary.
+  class RemoteSpecification
+    include MatchPlatform
+
+    attr_reader :name, :version, :platform
+    attr_accessor :source
+
+    def initialize(name, version, platform, source_uri)
+      @name     = name
+      @version  = version
+      @platform = platform
+      @source_uri = source_uri
+    end
+
+    # Needed before installs, since the arch matters then and quick
+    # specs don't bother to include the arch in the platform string
+    def fetch_platform
+      @platform = _remote_specification.platform
+    end
+
+    def full_name
+      if platform == Gem::Platform::RUBY or platform.nil? then
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    # Because Rubyforge cannot be trusted to provide valid specifications
+    # once the remote gem is downloaded, the backend specification will
+    # be swapped out.
+    def __swap__(spec)
+      @specification = spec
+    end
+
+  private
+
+    def _remote_specification
+      @specification ||= begin
+        Gem::SpecFetcher.new.fetch_spec([@name, @version, @platform], URI(@source_uri.to_s))
+      end
+    end
+
+    def method_missing(method, *args, &blk)
+      if Gem::Specification.new.respond_to?(method)
+        _remote_specification.send(method, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+end