bundler 1.6.0.pre.1 → 1.6.0.pre.2

data/lib/bundler/cli/binstubs.rb

@@ -0,0 +1,36 @@
+module Bundler
+  class CLI::Binstubs
+    attr_reader :options, :gems
+    def initialize(options, gems)
+      @options = options
+      @gems = gems
+    end
+
+    def run
+      Bundler.definition.validate_ruby!
+      Bundler.settings[:bin] = options["path"] if options["path"]
+      Bundler.settings[:bin] = nil if options["path"] && options["path"].empty?
+      installer = Installer.new(Bundler.root, Bundler.definition)
+
+      if gems.empty?
+        Bundler.ui.error "`bundle binstubs` needs at least one gem to run."
+        exit 1
+      end
+
+      gems.each do |gem_name|
+        spec = installer.specs.find{|s| s.name == gem_name }
+        unless spec
+          raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(
+            gem_name, Bundler.definition.specs)
+        end
+
+        if spec.name == "bundler"
+          Bundler.ui.warn "Sorry, Bundler can only be run via Rubygems."
+        else
+          installer.generate_bundler_executable_stubs(spec, :force => options[:force], :binstubs_cmd => true)
+        end
+      end
+    end
+
+  end
+end

data/lib/bundler/cli/cache.rb

@@ -0,0 +1,34 @@
+module Bundler
+  class CLI::Cache
+    attr_reader :options
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.definition.validate_ruby!
+      Bundler.definition.resolve_with_cache!
+      setup_cache_all
+      Bundler.load.cache
+      Bundler.settings[:no_prune] = true if options["no-prune"]
+      Bundler.load.lock
+    rescue GemNotFound => e
+      Bundler.ui.error(e.message)
+      Bundler.ui.warn "Run `bundle install` to install missing gems."
+      exit 1
+    end
+
+  private
+
+    def setup_cache_all
+      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+
+      if Bundler.definition.sources.any? { |s| !s.is_a?(Source::Rubygems) } && !Bundler.settings[:cache_all]
+        Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want "    \
+          "to package them as well, please pass the --all flag. This will be the default " \
+          "on Bundler 2.0."
+      end
+    end
+
+  end
+end

data/lib/bundler/cli/check.rb

@@ -0,0 +1,35 @@
+module Bundler
+  class CLI::Check
+    attr_reader :options
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.settings[:path] = File.expand_path(options[:path]) if options[:path]
+      begin
+        definition = Bundler.definition
+        definition.validate_ruby!
+        not_installed = definition.missing_specs
+      rescue GemNotFound, VersionConflict
+        Bundler.ui.error "Bundler can't satisfy your Gemfile's dependencies."
+        Bundler.ui.warn  "Install missing gems with `bundle install`."
+        exit 1
+      end
+
+      if not_installed.any?
+        Bundler.ui.error "The following gems are missing"
+        not_installed.each { |s| Bundler.ui.error " * #{s.name} (#{s.version})" }
+        Bundler.ui.warn "Install missing gems with `bundle install`"
+        exit 1
+      elsif !Bundler.default_lockfile.exist? && Bundler.settings[:frozen]
+        Bundler.ui.error "This bundle has been frozen, but there is no Gemfile.lock present"
+        exit 1
+      else
+        Bundler.load.lock unless options[:"dry-run"]
+        Bundler.ui.info "The Gemfile's dependencies are satisfied"
+      end
+    end
+
+  end
+end

data/lib/bundler/cli/clean.rb

@@ -0,0 +1,19 @@
+module Bundler
+  class CLI::Clean
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      if Bundler.settings[:path] || options[:force]
+        Bundler.load.clean(options[:"dry-run"])
+      else
+        Bundler.ui.error "Can only use bundle clean when --path is set or --force is set"
+        exit 1
+      end
+    end
+
+  end
+end

data/lib/bundler/cli/common.rb

@@ -0,0 +1,54 @@
+module Bundler
+  module CLI::Common
+    def self.without_groups_message
+      groups = Bundler.settings.without
+      group_list = [groups[0...-1].join(", "), groups[-1..-1]].
+        reject{|s| s.to_s.empty? }.join(" and ")
+      group_str = (groups.size == 1) ? "group" : "groups"
+      "Gems in the #{group_str} #{group_list} were not installed."
+    end
+
+    def self.select_spec(name, regex_match = nil)
+      specs = []
+      regexp = Regexp.new(name) if regex_match
+
+      Bundler.definition.specs.each do |spec|
+        return spec if spec.name == name
+        specs << spec if regexp && spec.name =~ regexp
+      end
+
+      case specs.count
+      when 0
+        raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+      when 1
+        specs.first
+      else
+        ask_for_spec_from(specs)
+      end
+    end
+
+    def self.ask_for_spec_from(specs)
+      if !$stdout.tty? && ENV['BUNDLE_SPEC_RUN'].nil?
+        raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+      end
+
+      specs.each_with_index do |spec, index|
+        Bundler.ui.info "#{index.succ} : #{spec.name}", true
+      end
+      Bundler.ui.info '0 : - exit -', true
+
+      num = Bundler.ui.ask('> ').to_i
+      num > 0 ? specs[num - 1] : nil
+    end
+
+    def self.gem_not_found_message(missing_gem_name, alternatives)
+      require 'bundler/similarity_detector'
+      message = "Could not find gem '#{missing_gem_name}'."
+      alternate_names = alternatives.map { |a| a.respond_to?(:name) ? a.name : a }
+      suggestions = SimilarityDetector.new(alternate_names).similar_word_list(missing_gem_name)
+      message += "\nDid you mean #{suggestions}?" if suggestions
+      message
+    end
+
+  end
+end

data/lib/bundler/cli/config.rb

@@ -0,0 +1,84 @@
+module Bundler
+  class CLI::Config
+    attr_reader :options, :thor
+    attr_accessor :args
+
+    def initialize(options, args, thor)
+      @options = options
+      @args = args
+      @thor = thor
+    end
+
+    def run
+      peek = args.shift
+
+      if peek && peek =~ /^\-\-/
+        name, scope = args.shift, $'
+      else
+        name, scope = peek, "global"
+      end
+
+      unless name
+        Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
+
+        Bundler.settings.all.each do |setting|
+          Bundler.ui.confirm "#{setting}"
+          thor.with_padding do
+            Bundler.settings.pretty_values_for(setting).each do |line|
+              Bundler.ui.info line
+            end
+          end
+          Bundler.ui.confirm ""
+        end
+        return
+      end
+
+      case scope
+      when "delete"
+        Bundler.settings.set_local(name, nil)
+        Bundler.settings.set_global(name, nil)
+      when "local", "global"
+        if args.empty?
+          Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
+          thor.with_padding do
+            Bundler.settings.pretty_values_for(name).each { |line| Bundler.ui.info line }
+          end
+          return
+        end
+
+        locations = Bundler.settings.locations(name)
+
+        if scope == "global"
+          if local = locations[:local]
+            Bundler.ui.info "Your application has set #{name} to #{local.inspect}. This will override the " \
+              "global value you are currently setting"
+          end
+
+          if env = locations[:env]
+            Bundler.ui.info "You have a bundler environment variable for #{name} set to #{env.inspect}. " \
+              "This will take precedence over the global value you are setting"
+          end
+
+          if global = locations[:global]
+            Bundler.ui.info "You are replacing the current global value of #{name}, which is currently #{global.inspect}"
+          end
+        end
+
+        if scope == "local" && local = locations[:local]
+          Bundler.ui.info "You are replacing the current local value of #{name}, which is currently #{local.inspect}"
+        end
+
+        if name.match(/\Alocal\./)
+          pathname = Pathname.new(args.join(" "))
+          self.args = [pathname.expand_path.to_s] if pathname.directory?
+        end
+
+        Bundler.settings.send("set_#{scope}", name, args.join(" "))
+      else
+        Bundler.ui.error "Invalid scope --#{scope} given. Please use --local or --global."
+        exit 1
+      end
+    end
+
+  end
+end

data/lib/bundler/cli/console.rb

@@ -0,0 +1,42 @@
+module Bundler
+  class CLI::Console
+    attr_reader :options, :group, :consoles
+    def initialize(options, group, consoles)
+      @options = options
+      @group = group
+      @consoles = consoles
+    end
+
+    def run
+      group ? Bundler.require(:default, *(group.split.map! {|g| g.to_sym })) : Bundler.require
+      ARGV.clear
+
+      preferred = Bundler.settings[:console] || 'irb'
+
+      # See if console is available
+      begin
+        require preferred || true
+      rescue LoadError
+        # Is it in Gemfile?
+        Bundler.ui.error "Could not load the #{preferred} console"
+        Bundler.ui.info "Falling back on IRB..."
+
+        require 'irb'
+        preferred = 'irb'
+      end
+
+      constant = consoles[preferred]
+
+      console = begin
+                  Object.const_get(constant)
+                rescue NameError => e
+                  Bundler.ui.error e.inspect
+                  Bundler.ui.error "Could not load the #{constant} console"
+                  return
+                end
+
+      console.start
+    end
+
+  end
+end

data/lib/bundler/cli/exec.rb

@@ -0,0 +1,37 @@
+module Bundler
+  class CLI::Exec
+    attr_reader :options, :args
+
+    def initialize(options, args)
+      @options = options
+      @args = args
+    end
+
+    def run
+      Bundler.definition.validate_ruby!
+      Bundler.load.setup_environment
+
+      begin
+        if RUBY_VERSION >= "2.0"
+          @args << { :close_others => !options.keep_file_descriptors? }
+        elsif options.keep_file_descriptors?
+          Bundler.ui.warn "Ruby version #{RUBY_VERSION} defaults to keeping non-standard file descriptors on Kernel#exec."
+        end
+
+        # Run
+        Kernel.exec(*args)
+      rescue Errno::EACCES
+        Bundler.ui.error "bundler: not executable: #{args.first}"
+        exit 126
+      rescue Errno::ENOENT
+        Bundler.ui.error "bundler: command not found: #{args.first}"
+        Bundler.ui.warn  "Install missing gem executables with `bundle install`"
+        exit 127
+      rescue ArgumentError
+        Bundler.ui.error "bundler: exec needs a command to run"
+        exit 128
+      end
+    end
+
+  end
+end

data/lib/bundler/cli/gem.rb

@@ -0,0 +1,61 @@
+module Bundler
+  class CLI::Gem
+    attr_reader :options, :gem_name, :thor
+    def initialize(options, gem_name, thor)
+      @options = options
+      @gem_name = gem_name
+      @thor = thor
+    end
+
+    def run
+      name = gem_name.chomp("/") # remove trailing slash if present
+      namespaced_path = name.tr('-', '/')
+      target = File.join(Dir.pwd, name)
+      constant_name = name.split('_').map{|p| p[0..0].upcase + p[1..-1] }.join
+      constant_name = constant_name.split('-').map{|q| q[0..0].upcase + q[1..-1] }.join('::') if constant_name =~ /-/
+      constant_array = constant_name.split('::')
+      git_user_name = `git config user.name`.chomp
+      git_user_email = `git config user.email`.chomp
+      opts = {
+        :name            => name,
+        :namespaced_path => namespaced_path,
+        :constant_name   => constant_name,
+        :constant_array  => constant_array,
+        :author          => git_user_name.empty? ? "TODO: Write your name" : git_user_name,
+        :email           => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
+        :test            => options[:test]
+      }
+      gemspec_dest = File.join(target, "#{name}.gemspec")
+      thor.template(File.join("newgem/Gemfile.tt"),               File.join(target, "Gemfile"),                             opts)
+      thor.template(File.join("newgem/Rakefile.tt"),              File.join(target, "Rakefile"),                            opts)
+      thor.template(File.join("newgem/LICENSE.txt.tt"),           File.join(target, "LICENSE.txt"),                         opts)
+      thor.template(File.join("newgem/README.md.tt"),             File.join(target, "README.md"),                           opts)
+      thor.template(File.join("newgem/gitignore.tt"),             File.join(target, ".gitignore"),                          opts)
+      thor.template(File.join("newgem/newgem.gemspec.tt"),        gemspec_dest,                                             opts)
+      thor.template(File.join("newgem/lib/newgem.rb.tt"),         File.join(target, "lib/#{namespaced_path}.rb"),           opts)
+      thor.template(File.join("newgem/lib/newgem/version.rb.tt"), File.join(target, "lib/#{namespaced_path}/version.rb"),   opts)
+      if options[:bin]
+        thor.template(File.join("newgem/bin/newgem.tt"),          File.join(target, 'bin', name),                           opts)
+      end
+      case options[:test]
+      when 'rspec'
+        thor.template(File.join("newgem/rspec.tt"),               File.join(target, ".rspec"),                              opts)
+        thor.template(File.join("newgem/spec/spec_helper.rb.tt"), File.join(target, "spec/spec_helper.rb"),                 opts)
+        thor.template(File.join("newgem/spec/newgem_spec.rb.tt"), File.join(target, "spec/#{namespaced_path}_spec.rb"),     opts)
+      when 'minitest'
+        thor.template(File.join("newgem/test/minitest_helper.rb.tt"), File.join(target, "test/minitest_helper.rb"),         opts)
+        thor.template(File.join("newgem/test/test_newgem.rb.tt"),     File.join(target, "test/test_#{namespaced_path}.rb"), opts)
+      end
+      if options[:test]
+        thor.template(File.join("newgem/.travis.yml.tt"),         File.join(target, ".travis.yml"),            opts)
+      end
+      Bundler.ui.info "Initializing git repo in #{target}"
+      Dir.chdir(target) { `git init`; `git add .` }
+
+      if options[:edit]
+        thor.run("#{options["edit"]} \"#{gemspec_dest}\"")  # Open gemspec in editor
+      end
+    end
+
+  end
+end

data/lib/bundler/cli/init.rb

@@ -0,0 +1,33 @@
+module Bundler
+  class CLI::Init
+    attr_reader :options
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      if File.exist?("Gemfile")
+        Bundler.ui.error "Gemfile already exists at #{Dir.pwd}/Gemfile"
+        exit 1
+      end
+
+      if options[:gemspec]
+        gemspec = File.expand_path(options[:gemspec])
+        unless File.exist?(gemspec)
+          Bundler.ui.error "Gem specification #{gemspec} doesn't exist"
+          exit 1
+        end
+        spec = Gem::Specification.load(gemspec)
+        puts "Writing new Gemfile to #{Dir.pwd}/Gemfile"
+        File.open('Gemfile', 'wb') do |file|
+          file << "# Generated from #{gemspec}\n"
+          file << spec.to_gemfile
+        end
+      else
+        puts "Writing new Gemfile to #{Dir.pwd}/Gemfile"
+        FileUtils.cp(File.expand_path('../../templates/Gemfile', __FILE__), 'Gemfile')
+      end
+    end
+
+  end
+end