rkh-bundler 1.2.0.pre

data/lib/bundler/endpoint_specification.rb

@@ -0,0 +1,78 @@
+require 'uri'
+
+module Bundler
+  # used for Creating Specifications from the Gemcutter Endpoint
+  class EndpointSpecification < Gem::Specification
+    include MatchPlatform
+
+    attr_reader :name, :version, :platform, :dependencies
+    attr_accessor :source
+
+    def initialize(name, version, platform, dependencies)
+      @name         = name
+      @version      = version
+      @platform     = platform
+      @dependencies = dependencies
+    end
+
+    def fetch_platform
+      @plaftorm
+    end
+
+    # needed for standalone, load required_paths from local gemspec
+    # after the gem in installed
+    def require_paths
+      if @remote_specification
+        @remote_specification.require_paths
+      elsif _local_specification
+        _local_specification.require_paths
+      else
+        super
+      end
+    end
+
+    # needed for binstubs
+    def executables
+      if @remote_specification
+        @remote_specification.executables
+      elsif _local_specification
+        _local_specification.executables
+      else
+        super
+      end
+    end
+
+    # needed for bundle clean
+    def bindir
+      if @remote_specification
+        @remote_specification.bindir
+      elsif _local_specification
+        _local_specification.bindir
+      else
+        super
+      end
+    end
+
+    # needed for post_install_messages during install
+    def post_install_message
+      if @remote_specification
+        @remote_specification.post_install_message
+      elsif _local_specification
+        _local_specification.post_install_message
+      end
+    end
+
+    def _local_specification
+      eval(File.read(local_specification_path)) if @loaded_from && File.exists?(local_specification_path)
+    end
+
+    def __swap__(spec)
+      @remote_specification = spec
+    end
+
+    private
+    def local_specification_path
+      "#{base_dir}/specifications/#{full_name}.gemspec"
+    end
+  end
+end

data/lib/bundler/environment.rb

@@ -0,0 +1,47 @@
+module Bundler
+  class Environment
+    attr_reader :root
+
+    def initialize(root, definition)
+      @root = root
+      @definition = definition
+
+      env_file = Bundler.app_config_path.join('environment.rb')
+      env_file.rmtree if env_file.exist?
+    end
+
+    def inspect
+      @definition.to_lock.inspect
+    end
+
+    # TODO: Remove this method. It's used in cli.rb still
+    def index
+      @definition.index
+    end
+
+    def requested_specs
+      @definition.requested_specs
+    end
+
+    def specs
+      @definition.specs
+    end
+
+    def dependencies
+      @definition.dependencies
+    end
+
+    def current_dependencies
+      @definition.current_dependencies
+    end
+
+    def lock
+      @definition.lock(Bundler.default_lockfile)
+    end
+
+    def update(*gems)
+      # Nothing
+    end
+
+  end
+end

data/lib/bundler/fetcher.rb

@@ -0,0 +1,225 @@
+require 'uri'
+require 'net/http/persistent'
+
+module Bundler
+  # Handles all the fetching with the rubygems server
+  class Fetcher
+    REDIRECT_LIMIT = 5
+
+    attr_reader :has_api
+
+    class << self
+      attr_accessor :disable_endpoint
+
+      @@spec_fetch_map ||= {}
+
+      def fetch(spec)
+        spec, uri = @@spec_fetch_map[spec.full_name]
+        if spec
+          path = download_gem_from_uri(spec, uri)
+          s = Bundler.rubygems.spec_from_gem(path)
+          spec.__swap__(s)
+        end
+      end
+
+      def download_gem_from_uri(spec, uri)
+        spec.fetch_platform
+
+        download_path = Bundler.requires_sudo? ? Bundler.tmp : Bundler.rubygems.gem_dir
+        gem_path = "#{Bundler.rubygems.gem_dir}/cache/#{spec.full_name}.gem"
+
+        FileUtils.mkdir_p("#{download_path}/cache")
+        Bundler.rubygems.download_gem(spec, uri, download_path)
+
+        if Bundler.requires_sudo?
+          Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/cache"
+          Bundler.sudo "mv #{Bundler.tmp}/cache/#{spec.full_name}.gem #{gem_path}"
+        end
+
+        gem_path
+      end
+    end
+
+    def initialize(remote_uri)
+      @remote_uri = remote_uri
+      @has_api    = true # will be set to false if the rubygems index is ever fetched
+      @@connection ||= Net::HTTP::Persistent.new nil, :ENV
+    end
+
+    # fetch a gem specification
+    def fetch_spec(spec)
+      spec = spec - [nil, 'ruby', '']
+      spec_file_name = "#{spec.join '-'}.gemspec.rz"
+
+      uri = URI.parse("#{@remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}")
+
+      spec_rz = (uri.scheme == "file") ? Gem.read_binary(uri.path) : fetch(uri)
+      Marshal.load Gem.inflate(spec_rz)
+    end
+
+    # return the specs in the bundler format as an index
+    def specs(gem_names, source)
+      index = Index.new
+
+      if !gem_names || @remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
+        Bundler.ui.info "Fetching source index from #{strip_user_pass_from_uri(@remote_uri)}"
+        specs = fetch_all_remote_specs
+      else
+        Bundler.ui.info "Fetching gem metadata from #{strip_user_pass_from_uri(@remote_uri)}", Bundler.ui.debug?
+        begin
+          specs = fetch_remote_specs(gem_names)
+        # fall back to the legacy index in the following cases
+        # 1. Gemcutter Endpoint doesn't return a 200
+        # 2. Marshal blob doesn't load properly
+        # 3. One of the YAML gemspecs has the Syck::DefaultKey problem
+        rescue HTTPError, TypeError => e
+          # new line now that the dots are over
+          Bundler.ui.info "" unless Bundler.ui.debug?
+
+          if @remote_uri.to_s.include?("rubygems.org")
+            Bundler.ui.info "Error #{e.class} during request to dependency API"
+          end
+          Bundler.ui.debug e.message
+          Bundler.ui.debug e.backtrace
+
+          Bundler.ui.info "Fetching full source index from #{strip_user_pass_from_uri(@remote_uri)}"
+          specs = fetch_all_remote_specs
+        else
+          # new line now that the dots are over
+          Bundler.ui.info "" unless Bundler.ui.debug?
+        end
+      end
+
+      specs[@remote_uri].each do |name, version, platform, dependencies|
+        next if name == 'bundler'
+        spec = nil
+        if dependencies
+          spec = EndpointSpecification.new(name, version, platform, dependencies)
+        else
+          spec = RemoteSpecification.new(name, version, platform, self)
+        end
+        spec.source = source
+        @@spec_fetch_map[spec.full_name] = [spec, @remote_uri]
+        index << spec
+      end
+
+      index
+    end
+
+    # fetch index
+    def fetch_remote_specs(gem_names, full_dependency_list = [], last_spec_list = [])
+      query_list = gem_names - full_dependency_list
+
+      # only display the message on the first run
+      if Bundler.ui.debug?
+        Bundler.ui.debug "Query List: #{query_list.inspect}"
+      else
+        Bundler.ui.info ".", false
+      end
+
+      return {@remote_uri => last_spec_list} if query_list.empty?
+
+      spec_list, deps_list = fetch_dependency_remote_specs(query_list)
+      returned_gems = spec_list.map {|spec| spec.first }.uniq
+
+      fetch_remote_specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list)
+    end
+
+  private
+
+    def fetch(uri, counter = 0)
+      raise HTTPError, "Too many redirects" if counter >= REDIRECT_LIMIT
+
+      begin
+        Bundler.ui.debug "Fetching from: #{uri}"
+        response = @@connection.request(uri)
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+             SocketError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+             Net::HTTP::Persistent::Error, Net::ProtocolError => e
+        raise HTTPError, "Network error while fetching #{uri}"
+      end
+
+      case response
+      when Net::HTTPRedirection
+        Bundler.ui.debug("HTTP Redirection")
+        new_uri = URI.parse(response["location"])
+        new_uri.user = uri.user
+        new_uri.password = uri.password
+        fetch(new_uri, counter + 1)
+      when Net::HTTPSuccess
+        Bundler.ui.debug("HTTP Success")
+        response.body
+      else
+        Bundler.ui.debug("HTTP Error")
+        raise HTTPError
+      end
+    end
+
+    # fetch from Gemcutter Dependency Endpoint API
+    def fetch_dependency_remote_specs(gem_names)
+      Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(' ')}"
+      encoded_gem_names = URI.encode(gem_names.join(","))
+      uri = URI.parse("#{@remote_uri}api/v1/dependencies?gems=#{encoded_gem_names}")
+      marshalled_deps = fetch(uri)
+      gem_list = Marshal.load(marshalled_deps)
+      deps_list = []
+
+      spec_list = gem_list.map do |s|
+        dependencies = s[:dependencies].map do |d|
+          begin
+            name, requirement = d
+            dep = Gem::Dependency.new(name, requirement.split(", "))
+          rescue ArgumentError => e
+            if e.message.include?('Illformed requirement ["#<YAML::Syck::DefaultKey')
+              puts # we shouldn't print the error message on the "fetching info" status line
+              raise GemspecError, %{Unfortunately, the gem #{s[:name]} (#{s[:number]}) } +
+                %{has an invalid gemspec. As a result, Bundler cannot install this Gemfile. } +
+                %{Please ask the gem author to yank the bad version to fix this issue. For } +
+                %{more information, see http://bit.ly/syck-defaultkey. For a temporary } +
+                %{workaround try using the --full-index option.}
+            else
+              raise e
+            end
+          end
+
+          deps_list << dep.name
+
+          dep
+        end
+
+        [s[:name], Gem::Version.new(s[:number]), s[:platform], dependencies]
+      end
+
+      [spec_list, deps_list.uniq]
+    end
+
+    # fetch from modern index: specs.4.8.gz
+    def fetch_all_remote_specs
+      @has_api = false
+      Gem.sources = ["#{@remote_uri}"]
+      spec_list = Hash.new { |h,k| h[k] = [] }
+      begin
+        # Fetch all specs, minus prerelease specs
+        spec_list = Gem::SpecFetcher.new.list(true, false)
+        # Then fetch the prerelease specs
+        begin
+          Gem::SpecFetcher.new.list(false, true).each {|k, v| spec_list[k] += v }
+        rescue Gem::RemoteFetcher::FetchError
+          Bundler.ui.debug "Could not fetch prerelease specs from #{strip_user_pass_from_uri(@remote_uri)}"
+        end
+      rescue Gem::RemoteFetcher::FetchError
+        raise Bundler::HTTPError, "Could not reach #{strip_user_pass_from_uri(@remote_uri)}"
+      end
+
+      return spec_list
+    end
+
+    def strip_user_pass_from_uri(uri)
+      uri_dup = uri.dup
+      uri_dup.user = "****" if uri_dup.user
+      uri_dup.password = "****" if uri_dup.password
+
+      uri_dup
+    end
+  end
+end

data/lib/bundler/gem_helper.rb

@@ -0,0 +1,162 @@
+$:.unshift File.expand_path('../vendor', __FILE__)
+require 'thor'
+require 'bundler'
+
+module Bundler
+  class GemHelper
+    include Rake::DSL if defined? Rake::DSL
+
+    class << self
+      # set when install'd.
+      attr_accessor :instance
+
+      def install_tasks(opts = {})
+        new(opts[:dir], opts[:name]).install
+      end
+
+      def gemspec(&block)
+        gemspec = instance.gemspec
+        block.call(gemspec) if block
+        gemspec
+      end
+    end
+
+    attr_reader :spec_path, :base, :gemspec
+
+    def initialize(base = nil, name = nil)
+      Bundler.ui = UI::Shell.new(Thor::Base.shell.new)
+      @base = (base ||= Dir.pwd)
+      gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "{,*}.gemspec")]
+      raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
+      @spec_path = gemspecs.first
+      @gemspec = Bundler.load_gemspec(@spec_path)
+    end
+
+    def install
+      desc "Build #{name}-#{version}.gem into the pkg directory"
+      task 'build' do
+        build_gem
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems"
+      task 'install' do
+        install_gem
+      end
+
+      desc "Create tag #{version_tag} and build and push #{name}-#{version}.gem to Rubygems"
+      task 'release' do
+        release_gem
+      end
+
+      GemHelper.instance = self
+    end
+
+    def build_gem
+      file_name = nil
+      sh("gem build -V '#{spec_path}'") { |out, code|
+        file_name = File.basename(built_gem_path)
+        FileUtils.mkdir_p(File.join(base, 'pkg'))
+        FileUtils.mv(built_gem_path, 'pkg')
+        Bundler.ui.confirm "#{name} #{version} built to pkg/#{file_name}"
+      }
+      File.join(base, 'pkg', file_name)
+    end
+
+    def install_gem
+      built_gem_path = build_gem
+      out, _ = sh_with_code("gem install '#{built_gem_path}'")
+      raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output" unless out[/Successfully installed/]
+      Bundler.ui.confirm "#{name} (#{version}) installed"
+    end
+
+    def release_gem
+      guard_clean
+      guard_already_tagged
+      built_gem_path = build_gem
+      tag_version {
+        git_push
+        rubygem_push(built_gem_path)
+      }
+    end
+
+    protected
+    def rubygem_push(path)
+      if Pathname.new("~/.gem/credentials").expand_path.exist?
+        sh("gem push '#{path}'")
+        Bundler.ui.confirm "Pushed #{name} #{version} to rubygems.org"
+      else
+        raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
+      end
+    end
+
+    def built_gem_path
+      Dir[File.join(base, "#{name}-*.gem")].sort_by{|f| File.mtime(f)}.last
+    end
+
+    def git_push
+      perform_git_push
+      perform_git_push ' --tags'
+      Bundler.ui.confirm "Pushed git commits and tags"
+    end
+
+    def perform_git_push(options = '')
+      cmd = "git push #{options}"
+      out, code = sh_with_code(cmd)
+      raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n" unless code == 0
+    end
+
+    def guard_already_tagged
+      if sh('git tag').split(/\n/).include?(version_tag)
+        raise("This tag has already been committed to the repo.")
+      end
+    end
+
+    def guard_clean
+      clean? or raise("There are files that need to be committed first.")
+    end
+
+    def clean?
+      sh_with_code("git diff --exit-code")[1] == 0
+    end
+
+    def tag_version
+      sh "git tag -a -m \"Version #{version}\" #{version_tag}"
+      Bundler.ui.confirm "Tagged #{version_tag}"
+      yield if block_given?
+    rescue
+      Bundler.ui.error "Untagged #{version_tag} due to error"
+      sh_with_code "git tag -d #{version_tag}"
+      raise
+    end
+
+    def version
+      gemspec.version
+    end
+
+    def version_tag
+      "v#{version}"
+    end
+
+    def name
+      gemspec.name
+    end
+
+    def sh(cmd, &block)
+      out, code = sh_with_code(cmd, &block)
+      code == 0 ? out : raise(out.empty? ? "Running `#{cmd}' failed. Run this command directly for more detailed output." : out)
+    end
+
+    def sh_with_code(cmd, &block)
+      cmd << " 2>&1"
+      outbuf = ''
+      Bundler.ui.debug(cmd)
+      Dir.chdir(base) {
+        outbuf = `#{cmd}`
+        if $? == 0
+          block.call(outbuf) if block
+        end
+      }
+      [outbuf, $?]
+    end
+  end
+end