autoproj 2.0.0.rc3 → 2.0.0.rc4

data/bin/autoproj_bootstrap.in

@@ -5,260 +5,8 @@ if RUBY_VERSION < "1.9.2"
     exit 1
 end
 
-require 'rbconfig'
-module Autobuild
-    @windows = RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw|[Ww]indows)!
-    def self.windows?
-        @windows
-    end
-
-    @macos =  RbConfig::CONFIG["host_os"] =~ %r!([Dd]arwin)!
-    def self.macos?
-        @macos
-    end
-end
-
-require 'yaml'
-require 'set'
-
-module Autoproj
-    class ConfigError < RuntimeError; end
-    class << self
-        attr_reader :verbose
-    end
-
-    def self.color(string, *args)
-        string
-    end
-
-    def self.warn(str, *args)
-        STDERR.puts "WARN #{str}"
-    end
-    def self.message(str)
-        STDERR.puts "  #{str}"
-    end
-end
-
-module Autobuild
-    class Exception < RuntimeError; end
-
-    def self.do_update
-        true
-    end
-    def self.message(str)
-        STDERR.puts "  #{str}"
-    end
-    def self.progress(key, str)
-        STDERR.puts "  #{str}"
-    end
-    def self.progress_done(key)
-    end
-    def self.message(str)
-        STDERR.puts "  #{str}"
-    end
-
-    class << self
-        attr_reader :programs
-    end
-    @programs = Hash.new
-    def self.tool(name)
-        # Let the ability to set programs[name] to nil to make sure we don't use
-        # that program. This is used later on in this file to make sure we
-        # aren't using the wrong rubygems binary
-        if programs.has_key?(name)
-            programs[name]
-        else
-            name
-        end
-    end
-
-    module Subprocess
-        def self.run(name, phase, *cmd)
-            if cmd.last.kind_of?(Hash)
-                options = cmd.pop
-                (options[:env] || Hash.new).each do |k, v|
-                    ENV[k] = v
-                end
-            end
-
-            output = `#{cmd.join(" ")}`
-            if $?.exitstatus != 0
-                STDERR.puts "ERROR: failed to run #{cmd.join(" ")}"
-                STDERR.puts "ERROR: command output is: #{output}"
-                exit 1
-            end
-        end
-    end
-end
-
-BUILD_OPTION_CODE
-CONFIG_CODE
-module Autoproj
-    def self.config
-        @config ||= Configuration.new
-    end
-end
-
-OSDEPS_CODE
-TOOLS_CODE
-SYSTEM_CODE
-
-DEFS = <<EODEFS
-OSDEPS_DEFAULTS
-EODEFS
-
-# Override Autoproj.root_dir
-module Autoproj
-    def self.root_dir
-        @root_dir
-    end
-    @root_dir = Dir.pwd
-end
-
-if File.directory?(File.join(Autoproj.root_dir, 'autoproj'))
-    STDERR.puts "there is already an autoproj/ directory here, cannot bootstrap"
-    STDERR.puts "Either delete it and attempt bootstrapping again, or source env.sh"
-    STDERR.puts "and use the usual autoproj workflow"
-    exit 1
-end
-
-if defined? Encoding # This is a 1.9-only thing
-    Encoding.default_internal = Encoding::UTF_8
-    Encoding.default_external = Encoding::UTF_8
-end
-
-if ENV['AUTOPROJ_CURRENT_ROOT'] && ENV['AUTOPROJ_CURRENT_ROOT'] != Dir.pwd
-    STDERR.puts "the env.sh from #{ENV['AUTOPROJ_CURRENT_ROOT']} seem to already be sourced"
-    STDERR.puts "start a new shell and try to bootstrap again"
-    exit 1
-end
-
-require 'set'
-curdir_entries = Dir.entries('.').to_set - [".", "..", "autoproj_bootstrap", ".gems", 'env.sh'].to_set
-if !curdir_entries.empty? && ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] != '1'
-    while true
-        print "The current directory is not empty, continue bootstrapping anyway ? [yes] "
-        STDOUT.flush 
-        answer = STDIN.readline.chomp
-        if answer == "no"
-            exit
-        elsif answer == "" || answer == "yes"
-            # Set the environment variable since we might restart the
-            # autoproj_bootstrap script and -- anyway -- will run "autoproj
-            # bootstrap" later on
-            break
-        else
-            STDOUT.puts "invalid answer. Please answer 'yes' or 'no'"
-            STDOUT.flush
-        end
-    end
-end
-
-# While in here, we don't have utilrb
-module Kernel
-    def filter_options(options, defaults)
-        options = options.dup
-        filtered = Hash.new
-        defaults.each do |k, v|
-            filtered[k] =
-                if options.has_key?(k) then options.delete(k)
-                else v
-                end
-        end
-        return filtered, options
-    end
-    def validate_options(options, defaults)
-        defaults.merge(options)
-    end
-end
-
-# Environment is clean, so just mark it as so unconditionally
-ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] = '1'
-
-gem_home = ENV['AUTOPROJ_GEM_HOME'] || File.join(Dir.pwd, '.gems')
-gem_path = ([gem_home] + Gem.default_path).join(":")
-Gem.paths = Hash['GEM_HOME' => gem_home, 'GEM_PATH' => gem_path]
-
-ENV['GEM_HOME'] = gem_home
-ENV['GEM_PATH'] = gem_path
-ENV['PATH']     = "#{ENV['GEM_HOME']}/bin:#{ENV['PATH']}"
-
-Autoproj::OSDependencies.define_osdeps_mode_option
-osdeps_mode = Autoproj::OSDependencies.osdeps_mode.join(",")
-ENV['AUTOPROJ_OSDEPS_MODE'] = osdeps_mode
-
-# First thing we do is install a proper ruby environment. We make sure that we
-# aren't installing any gems for now (as we need to choose the right gem
-# binary) by setting Autobuild.programs['gem'] to nil
-Autobuild.programs['gem'] = nil
-Autoproj::OSDependencies.autodetect_ruby
-Autoproj::OSDependencies.autodetect_ruby_program
-
-osdeps_management = 
-    if ENV['AUTOPROJ_DEFAULT_OSDEPS']
-        Autoproj::OSDependencies.load(ENV['AUTOPROJ_DEFAULT_OSDEPS'])
-    else
-        Autoproj::OSDependencies.new(YAML.load(DEFS))
-    end
-osdeps_management.silent = false
-Autoproj::PackageManagers::GemManager.gem_home = gem_home
-Autoproj::PackageManagers::GemManager.use_cache_dir
-
-begin
-    STDERR.puts "autoproj: installing a proper Ruby environment (this can take a long time)"
-    osdeps_management.install(['ruby'])
-rescue Autoproj::ConfigError => e
-    STDERR.puts "failed: #{e.message}"
-    exit(1)
-end
-
-# Now try to find out the name of the gem binary
-PACKAGES      = ['build-essential', 'sudo']
-
-STDERR.puts "autoproj: installing autoproj and its dependencies (this can take a long time)"
-# First install the dependencies of autoproj, as we don't want them to be
-# affected by the prerelease flag
-begin
-    if !PACKAGES.empty?
-        osdeps_management.install(PACKAGES)
-    end
-rescue Autoproj::ConfigError => e
-    STDERR.puts "failed: #{e.message}"
-    exit(1)
-end
-
-File.open('env.sh', 'w') do |io|
-    io.write <<-EOSHELL
-export RUBYOPT=-rubygems
-export GEM_PATH=#{gem_path}
-export GEM_HOME=#{gem_home}
-export PATH=$GEM_HOME/bin:$PATH
-    EOSHELL
-end
-
-# If the user specifies "dev" on the command line, install the prerelease
-# version of autoproj. If it is "localdev", expect him to install autoproj and
-# run autoproj bootstrap manually.
-if ARGV.first != "localdev"
-    if ARGV.first == "dev"
-        ENV['AUTOPROJ_USE_PRERELEASE'] = '1'
-        ARGV.shift
-    end
-
-    Autoproj::PackageManagers::GemManager.with_prerelease =
-        (ENV['AUTOPROJ_USE_PRERELEASE'] == '1')
-    begin
-        osdeps_management.install(['autobuild'])
-        osdeps_management.install(['autoproj'])
-    rescue Autoproj::ConfigError => e
-        STDERR.puts "failed: #{e.message}"
-        exit(1)
-    end
-    Autoproj::PackageManagers::GemManager.with_prerelease = false
-
-    if !system('autoproj', 'bootstrap', *ARGV)
-        STDERR.puts "ERROR: failed to run autoproj bootstrap #{ARGV.join(", ")}"
-        exit 1
-    end
-end
+AUTOPROJ_OPS_INSTALL
 
+ops = Autoproj::Ops::Install.new(Dir.pwd)
+ops.parse_options(ARGV)
+ops.run

data/bin/autoproj_install

@@ -0,0 +1,225 @@
+#! /usr/bin/ruby
+
+if RUBY_VERSION < "1.9.2"
+    STDERR.puts "autoproj requires Ruby >= 1.9.2"
+    exit 1
+end
+
+require 'optparse'
+require 'fileutils'
+require 'yaml'
+
+module Autoproj
+    module Ops
+        # This class contains the functionality necessary to install autoproj in a
+        # clean root
+        #
+        # It can be required standalone (i.e. does not depend on anything else than
+        # ruby and the ruby standard library)
+        class Install
+            # The directory in which to install autoproj
+            attr_reader :root_dir
+            # Content of the Gemfile generated to install autoproj itself
+            attr_accessor :gemfile
+
+            def initialize(root_dir)
+                @root_dir = root_dir
+                @gemfile  = default_gemfile_contents
+                @private_bundler  = false
+                @private_autoproj = false
+                @private_gems     = false
+            end
+
+            def dot_autoproj; File.join(root_dir, '.autoproj') end
+            def bin_dir; File.join(dot_autoproj, 'bin') end
+            def bundler_install_dir; File.join(dot_autoproj, 'bundler') end
+            def autoproj_install_dir; File.join(dot_autoproj, 'autoproj') end
+            # The path to the gemfile used to install autoproj
+            def autoproj_gemfile_path; File.join(autoproj_install_dir, 'Gemfile') end
+            def autoproj_config_path; File.join(dot_autoproj, 'config.yml') end
+
+            # Whether bundler should be installed locally in {#dot_autoproj}
+            def private_bundler?; @private_bundler end
+            # Whether autoproj should be installed locally in {#dot_autoproj}
+            def private_autoproj?; @private_autoproj end
+            # Whether bundler should be installed locally in the workspace
+            # prefix directory
+            def private_gems?; @private_gems end
+
+            def guess_gem_program
+                ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+                ruby_bindir = RbConfig::CONFIG['bindir']
+
+                candidates = ['gem']
+                if ruby_bin =~ /^ruby(.+)$/
+                    candidates << "gem#{$1}" 
+                end
+
+                candidates.each do |gem_name|
+                    if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
+                        return gem_full_path
+                    end
+                end
+                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
+            end
+
+            # The content of the default {#gemfile}
+            #
+            # @param [String] autoproj_version a constraint on the autoproj version
+            #   that should be used
+            # @return [String]
+            def default_gemfile_contents(autoproj_version = ">= 0")
+                ["source \"https://rubygems.org\"",
+                 "gem \"autoproj\", \"#{autoproj_version}\""].join("\n")
+            end
+
+            # Parse the provided command line options and returns the non-options
+            def parse_options(args = ARGV)
+                options = OptionParser.new do |opt|
+                    opt.on '--private-bundler', 'install bundler locally in the workspace' do
+                        @private_bundler = true
+                    end
+                    opt.on '--private-autoproj', 'install autoproj locally in the workspace' do
+                        @private_autoproj = true
+                    end
+                    opt.on '--private-gems', 'install gems locally in the prefix directory' do
+                        @private_gems = true
+                    end
+                    opt.on '--private', 'whether bundler, autoproj and the workspace gems should be installed locally in the workspace' do
+                        @private_bundler = true
+                        @private_autoproj = true
+                        @private_gems = true
+                    end
+                    opt.on '--version=VERSION_CONSTRAINT', String, 'use the provided string as a version constraint for autoproj' do |version|
+                        @gemfile = default_gemfile_contents(version)
+                    end
+                    opt.on '--gemfile=PATH', String, 'use the given Gemfile to install autoproj instead of the default' do |path|
+                        @gemfile = File.read(path)
+                    end
+                end
+                options.parse(ARGV)
+            end
+
+            def install_bundler
+                gem_program  = guess_gem_program
+                puts "Detected 'gem' to be #{gem_program}"
+
+                result = system(
+                    Hash['GEM_PATH' => nil,
+                         'GEM_HOME' => bundler_install_dir],
+                    gem_program, 'install', '--no-document', '--no-user-install', '--no-format-executable',
+                        "--bindir=#{File.join(bundler_install_dir, 'bin')}", 'bundler')
+
+                if !result
+                    STDERR.puts "FATAL: failed to install bundler in #{dot_autoproj}"
+                    exit 1
+                end
+                File.join(bin_dir, 'bundler')
+            end
+
+            def save_env_sh
+                env = Autobuild::Environment.new
+                path = []
+                if private_bundler?
+                    env.push_path 'PATH', File.join(bundler_install_dir, 'bin')
+                    env.push_path 'GEM_PATH', bundler_install_dir
+                end
+                env.push_path 'PATH', File.join(autoproj_install_dir, 'bin')
+                env.inherit 'PATH'
+                if private_autoproj?
+                    env.push_path 'GEM_PATH', autoproj_install_dir
+                end
+
+                # Generate environment files right now, we can at least use bundler
+                File.open(File.join(dot_autoproj, 'env.sh'), 'w') do |io|
+                    env.export_env_sh(io)
+                end
+
+                File.open(File.join(root_dir, 'env.sh'), 'w') do |io|
+                    io.write <<-EOSHELL
+source "#{File.join(dot_autoproj, 'env.sh')}"
+export AUTOPROJ_CURRENT_ROOT=#{root_dir}
+                    EOSHELL
+                end
+            end
+
+            def save_gemfile
+                FileUtils.mkdir_p File.dirname(autoproj_gemfile_path)
+                File.open(autoproj_gemfile_path, 'w') do |io|
+                    io.write gemfile
+                end
+            end
+            
+            def install_autoproj(bundler)
+                # Force bundler to update. If the user does not want this, let him specify a
+                # Gemfile with tighter version constraints
+                lockfile = File.join(File.dirname(autoproj_gemfile_path), 'Gemfile.lock')
+                if File.exist?(lockfile)
+                    FileUtils.rm lockfile
+                end
+
+                env = Hash['BUNDLE_GEMFILE' => nil, 'RUBYLIB' => nil]
+                opts = Array.new
+
+                if private_autoproj?
+                    env = Hash['GEM_PATH' => bundler_install_dir,
+                               'GEM_HOME' => nil]
+                    opts << "--clean" << "--path=#{autoproj_install_dir}"
+                end
+
+                result = system(env,
+                    bundler, 'install',
+                        "--gemfile=#{autoproj_gemfile_path}",
+                        "--binstubs=#{File.join(autoproj_install_dir, 'bin')}",
+                        *opts)
+                if !result
+                    STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
+                    exit 1
+                end
+            end
+
+            def update_configuration
+                if File.exist?(autoproj_config_path)
+                    config = YAML.load(File.read(autoproj_config_path)) || Hash.new
+                else
+                    config = Hash.new
+                end
+                config['private_bundler']  = private_bundler?
+                config['private_autoproj'] = private_autoproj?
+                config['private_gems']     = private_gems?
+                File.open(autoproj_config_path, 'w') do |io|
+                    YAML.dump(config, io)
+                end
+            end
+
+            def install
+                if private_bundler?
+                    puts "Installing bundler in #{bundler_install_dir}"
+                    bundler = install_bundler
+                end
+                save_gemfile
+                puts "Installing autoproj in #{dot_autoproj}"
+                install_autoproj(bundler || 'bundler')
+            end
+
+            # Actually perform the install
+            def run
+                install
+                ENV['BUNDLE_GEMFILE'] = autoproj_gemfile_path
+                require 'bundler'
+                Bundler.setup
+                require 'autobuild'
+                save_env_sh
+                update_configuration
+            end
+        end
+    end
+end
+
+
+
+ENV.delete('BUNDLE_GEMFILE')
+ENV.delete('RUBYLIB')
+ops = Autoproj::Ops::Install.new(Dir.pwd)
+ops.parse_options(ARGV)
+ops.run