bundler_package_git 1.1.pre.1

data/lib/bundler/deployment.rb

@@ -0,0 +1,53 @@
+module Bundler
+  class Deployment
+    def self.define_task(context, task_method = :task, opts = {})
+      if defined?(Capistrano) && context.is_a?(Capistrano::Configuration)
+        context_name = "capistrano"
+        role_default = "{:except => {:no_release => true}}"
+      else
+        context_name = "vlad"
+        role_default = "[:app]"
+      end
+
+      roles = context.fetch(:bundle_roles, false)
+      opts[:roles] = roles if roles
+
+      context.send :namespace, :bundle do
+        send :desc, <<-DESC
+          Install the current Bundler environment. By default, gems will be \
+          installed to the shared/bundle path. Gems in the development and \
+          test group will not be installed. The install command is executed \
+          with the --deployment and --quiet flags. If the bundle cmd cannot \
+          be found then you can override the bundle_cmd variable to specifiy \
+          which one it should use.
+
+          You can override any of these defaults by setting the variables shown below.
+
+          N.B. bundle_roles must be defined before you require 'bundler/#{context_name}' \
+          in your deploy.rb file.
+
+            set :bundle_gemfile,  "Gemfile"
+            set :bundle_dir,      File.join(fetch(:shared_path), 'bundle')
+            set :bundle_flags,    "--deployment --quiet"
+            set :bundle_without,  [:development, :test]
+            set :bundle_cmd,      "bundle" # e.g. "/opt/ruby/bin/bundle"
+            set :bundle_roles,    #{role_default} # e.g. [:app, :batch]
+        DESC
+        send task_method, :install, opts do
+          bundle_cmd     = context.fetch(:bundle_cmd, "bundle")
+          bundle_flags   = context.fetch(:bundle_flags, "--deployment --quiet")
+          bundle_dir     = context.fetch(:bundle_dir, File.join(context.fetch(:shared_path), 'bundle'))
+          bundle_gemfile = context.fetch(:bundle_gemfile, "Gemfile")
+          bundle_without = [*context.fetch(:bundle_without, [:development, :test])].compact
+
+          args = ["--gemfile #{File.join(context.fetch(:current_release), bundle_gemfile)}"]
+          args << "--path #{bundle_dir}" unless bundle_dir.to_s.empty?
+          args << bundle_flags.to_s
+          args << "--without #{bundle_without.join(" ")}" unless bundle_without.empty?
+
+          run "#{bundle_cmd} install #{args.join(' ')}"
+        end
+      end
+    end
+  end
+end

data/lib/bundler/dsl.rb

@@ -0,0 +1,243 @@
+require 'bundler/dependency'
+
+module Bundler
+  class Dsl
+    def self.evaluate(gemfile, lockfile, unlock)
+      builder = new
+      builder.instance_eval(Bundler.read_file(gemfile.to_s), gemfile.to_s, 1)
+      builder.to_definition(lockfile, unlock)
+    end
+
+    VALID_PLATFORMS = Bundler::Dependency::PLATFORM_MAP.keys.freeze
+
+    def initialize
+      @rubygems_source = Source::Rubygems.new
+      @source          = nil
+      @sources         = []
+      @dependencies    = []
+      @groups          = []
+      @platforms       = []
+      @env             = nil
+    end
+
+    def gemspec(opts = nil)
+      path              = opts && opts[:path] || '.'
+      name              = opts && opts[:name] || '*'
+      development_group = opts && opts[:development_group] || :development
+      path              = File.expand_path(path, Bundler.default_gemfile.dirname)
+      gemspecs = Dir[File.join(path, "#{name}.gemspec")]
+
+      case gemspecs.size
+      when 1
+        spec = Bundler.load_gemspec(gemspecs.first)
+        raise InvalidOption, "There was an error loading the gemspec at #{gemspecs.first}." unless spec
+        gem spec.name, :path => path
+        group(development_group) do
+          spec.development_dependencies.each do |dep|
+            gem dep.name, *dep.requirement.as_list
+          end
+        end
+      when 0
+        raise InvalidOption, "There are no gemspecs at #{path}."
+      else
+        raise InvalidOption, "There are multiple gemspecs at #{path}. Please use the :name option to specify which one."
+      end
+    end
+
+    def gem(name, *args)
+      if name.is_a?(Symbol)
+        raise GemfileError, %{You need to specify gem names as Strings. Use 'gem "#{name.to_s}"' instead.}
+      end
+
+      options = Hash === args.last ? args.pop : {}
+      version = args || [">= 0"]
+
+      _deprecated_options(options)
+      _normalize_options(name, version, options)
+
+      dep = Dependency.new(name, version, options)
+
+      if current = @dependencies.find { |d| d.name == dep.name }
+        if current.requirement != dep.requirement
+          raise DslError, "You cannot specify the same gem twice with different version requirements. " \
+                          "You specified: #{current.name} (#{current.requirement}) and " \
+                          "#{dep.name} (#{dep.requirement})"
+        end
+
+        if current.source != dep.source
+          raise DslError, "You cannot specify the same gem twice coming from different sources. You " \
+                          "specified that #{dep.name} (#{dep.requirement}) should come from " \
+                          "#{current.source || 'an unspecfied source'} and #{dep.source}"
+        end
+      end
+      @dependencies << Dependency.new(name, version, options)
+    end
+
+    def source(source, options = {})
+      case source
+      when :gemcutter, :rubygems, :rubyforge then
+        rubygems_source "http://rubygems.org"
+        return
+      when String
+        rubygems_source source
+        return
+      end
+
+      @source = source
+      options[:prepend] ? @sources.unshift(@source) : @sources << @source
+
+      yield if block_given?
+      @source
+    ensure
+      @source = nil
+    end
+
+    def path(path, options = {}, source_options = {}, &blk)
+      source Source::Path.new(_normalize_hash(options).merge("path" => Pathname.new(path))), source_options, &blk
+    end
+
+    def git(uri, options = {}, source_options = {}, &blk)
+      unless block_given?
+        msg = "You can no longer specify a git source by itself. Instead, \n" \
+              "either use the :git option on a gem, or specify the gems that \n" \
+              "bundler should find in the git source by passing a block to \n" \
+              "the git method, like: \n\n" \
+              "  git 'git://github.com/rails/rails.git' do\n" \
+              "    gem 'rails'\n" \
+              "  end"
+        raise DeprecatedError, msg
+      end
+
+      source Source::Git.new(_normalize_hash(options).merge("uri" => uri)), source_options, &blk
+    end
+
+    def to_definition(lockfile, unlock)
+      @sources << @rubygems_source
+      @sources.uniq!
+      Definition.new(lockfile, @dependencies, @sources, unlock)
+    end
+
+    def group(*args, &blk)
+      @groups.concat args
+      yield
+    ensure
+      args.each { @groups.pop }
+    end
+
+    def platforms(*platforms)
+      @platforms.concat platforms
+      yield
+    ensure
+      platforms.each { @platforms.pop }
+    end
+    alias_method :platform, :platforms
+
+    def env(name)
+      @env, old = name, @env
+      yield
+    ensure
+      @env = old
+    end
+
+    # Deprecated methods
+
+    def self.deprecate(name, replacement = nil)
+      define_method(name) do |*|
+        message = "'#{name}' has been removed from the Gemfile DSL, "
+        if replacement
+          message << "and has been replaced with '#{replacement}'."
+        else
+          message << "and is no longer supported."
+        end
+        message << "\nSee the README for more information on upgrading from Bundler 0.8."
+        raise DeprecatedError, message
+      end
+    end
+
+    deprecate :only, :group
+    deprecate :except
+    deprecate :disable_system_gems
+    deprecate :disable_rubygems
+    deprecate :clear_sources
+    deprecate :bundle_path
+    deprecate :bin_path
+
+  private
+
+    def rubygems_source(source)
+      @rubygems_source.add_remote source
+      @sources << @rubygems_source
+    end
+
+    def _normalize_hash(opts)
+      # Cannot modify a hash during an iteration in 1.9
+      opts.keys.each do |k|
+        next if String === k
+        v = opts[k]
+        opts.delete(k)
+        opts[k.to_s] = v
+      end
+      opts
+    end
+
+    def _normalize_options(name, version, opts)
+      _normalize_hash(opts)
+
+      invalid_keys = opts.keys - %w(group groups git path name branch ref tag require submodules platform platforms)
+      if invalid_keys.any?
+        plural = invalid_keys.size > 1
+        message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "
+        if plural
+          message << "as options for gem '#{name}', but they are invalid."
+        else
+          message << "as an option for gem '#{name}', but it is invalid."
+        end
+        raise InvalidOption, message
+      end
+
+      groups = @groups.dup
+      opts["group"] = opts.delete("groups") || opts["group"]
+      groups.concat Array(opts.delete("group"))
+      groups = [:default] if groups.empty?
+
+      platforms = @platforms.dup
+      opts["platforms"] = opts["platform"] || opts["platforms"]
+      platforms.concat Array(opts.delete("platforms"))
+      platforms.map! { |p| p.to_sym }
+      platforms.each do |p|
+        next if VALID_PLATFORMS.include?(p)
+        raise DslError, "`#{p}` is not a valid platform. The available options are: #{VALID_PLATFORMS.inspect}"
+      end
+
+      # Normalize git and path options
+      ["git", "path"].each do |type|
+        if param = opts[type]
+          if version.first && version.first =~ /^\s*=?\s*(\d[^\s]*)\s*$/
+            options = opts.merge("name" => name, "version" => $1)
+          else
+            options = opts.dup
+          end
+          source = send(type, param, options, :prepend => true) {}
+          opts["source"] = source
+        end
+      end
+
+      opts["source"]  ||= @source
+      opts["env"]     ||= @env
+      opts["platforms"] = platforms.dup
+      opts["group"]     = groups
+    end
+
+    def _deprecated_options(options)
+      if options.include?(:require_as)
+        raise DeprecatedError, "Please replace :require_as with :require"
+      elsif options.include?(:vendored_at)
+        raise DeprecatedError, "Please replace :vendored_at with :path"
+      elsif options.include?(:only)
+        raise DeprecatedError, "Please replace :only with :group"
+      elsif options.include?(:except)
+        raise DeprecatedError, "The :except option is no longer supported"
+      end
+    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,101 @@
+require 'uri'
+require 'net/http/persistent'
+
+module Bundler
+  class Fetcher
+    REDIRECT_LIMIT = 5
+
+    def initialize(remote_uri)
+      @remote_uri = remote_uri
+      @@connection ||= Net::HTTP::Persistent.new
+    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
+
+    # fetch index
+    def fetch_remote_specs(gem_names, full_dependency_list = [], last_spec_list = [], &blk)
+      return fetch_all_remote_specs(&blk) unless gem_names && @remote_uri.scheme != "file"
+
+      query_list = gem_names - full_dependency_list
+      Bundler.ui.debug "Query List: #{query_list.inspect}"
+      return {@remote_uri => last_spec_list}.each(&blk) if query_list.empty?
+
+      spec_list, deps_list = fetch_dependency_remote_specs(query_list, &blk)
+      returned_gems = spec_list.map {|spec| spec.first }.uniq
+
+      fetch_remote_specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list, &blk)
+    # 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
+    rescue HTTPError, TypeError => e
+      Bundler.ui.debug "Error #{e.class} from Gemcutter Dependency Endpoint API: #{e.message}"
+      Bundler.ui.debug e.backtrace
+      fetch_all_remote_specs(&blk)
+    end
+
+  private
+
+    def fetch(uri, counter = 0)
+      raise HTTPError, "Too many redirects" if counter >= REDIRECT_LIMIT
+
+      Bundler.ui.debug "Fetching from: #{uri}"
+      response = @@connection.request(uri)
+      case response
+      when Net::HTTPRedirection
+        Bundler.ui.debug("HTTP Redirection")
+        uri = URI.parse(response["location"])
+        fetch(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, &blk)
+      Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(' ')}"
+      uri = URI.parse("#{@remote_uri}api/v1/dependencies?gems=#{gem_names.join(",")}")
+      marshalled_deps = fetch(uri)
+      gem_list = Marshal.load(marshalled_deps)
+
+      spec_list = gem_list.map do |s|
+        [s[:name], Gem::Version.new(s[:number]), s[:platform]]
+      end
+      deps_list = gem_list.map do |s|
+        s[:dependencies].collect {|d| d.first }
+      end.flatten.uniq
+
+      [spec_list, deps_list]
+    end
+
+    # fetch from modern index: specs.4.8.gz
+    def fetch_all_remote_specs(&blk)
+      Bundler.ui.debug "Fetching modern index"
+      Gem.sources = ["#{@remote_uri}"]
+      begin
+        # Fetch all specs, minus prerelease specs
+        Gem::SpecFetcher.new.list(true, false).each(&blk)
+        # Then fetch the prerelease specs
+        begin
+          Gem::SpecFetcher.new.list(false, true).each(&blk)
+        rescue Gem::RemoteFetcher::FetchError
+          Bundler.ui.warn "Could not fetch prerelease specs from #{self}"
+        end
+      rescue Gem::RemoteFetcher::FetchError
+        Bundler.ui.warn "Could not reach #{self}"
+      end
+    end
+  end
+end

data/lib/bundler/gem_helper.rb

@@ -0,0 +1,146 @@
+$:.unshift File.expand_path('../vendor', __FILE__)
+require 'thor'
+require 'bundler'
+
+module Bundler
+  class GemHelper
+    def self.install_tasks(opts = {})
+      dir = opts[:dir] || Dir.pwd
+      self.new(dir, opts[:name]).install
+    end
+
+    attr_reader :spec_path, :base, :gemspec
+
+    def initialize(base, name = nil)
+      Bundler.ui = UI::Shell.new(Thor::Base.shell.new)
+      @base = base
+      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
+    end
+
+    def build_gem
+      file_name = nil
+      sh("gem build #{spec_path}") { |out, code|
+        raise out unless out[/Successfully/]
+        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)
+      out, _ = sh("gem push #{path}")
+      raise "Gem push failed due to lack of RubyGems.org credentials." if out[/Enter your RubyGems.org credentials/]
+      Bundler.ui.confirm "Pushed #{name} #{version} to rubygems.org"
+    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