autoproj 1.13.7 → 2.0.0.b1

data/lib/autoproj/package_set.rb

@@ -171,7 +171,7 @@ module Autoproj
             if vcs.local?
                 File.expand_path(vcs.url)
             else
-                File.expand_path(File.join(Autoproj.remotes_dir, vcs.create_autobuild_importer.repository_id.gsub(/[^\w]/, '_')))
+                File.expand_path(File.join(Autoproj.workspace.remotes_dir, vcs.create_autobuild_importer.repository_id.gsub(/[^\w]/, '_')))
             end
         end
 
@@ -182,7 +182,7 @@ module Autoproj
         # returns the corresponding VCSDefinition object
         def self.resolve_definition(manifest, raw_spec)
             if raw_spec.respond_to?(:to_str)
-                local_path = File.join(Autoproj.config_dir, raw_spec)
+                local_path = File.join(Autoproj.workspace.config_dir, raw_spec)
                 if File.directory?(local_path)
                     raw_spec = { :type => 'local', :url => local_path }
                 end
@@ -194,7 +194,7 @@ module Autoproj
             # either vcs_type:url or just url. In the latter case, we expect
             # 'url' to be a path to a local directory
             vcs_spec = Autoproj.expand(vcs_spec, manifest.constant_definitions)
-            return VCSDefinition.from_raw(vcs_spec, [[nil, raw_spec]]), options
+            return VCSDefinition.from_raw(vcs_spec, raw: [[nil, raw_spec]]), options
         end
 
         # Returns a string that uniquely represents the version control
@@ -238,7 +238,7 @@ module Autoproj
             if local?
                 return vcs.url 
             else
-                File.join(Autoproj.config_dir, 'remotes', name)
+                File.join(Autoproj.workspace.config_dir, 'remotes', name)
             end
         end
 
@@ -464,7 +464,7 @@ module Autoproj
                         name_match = Regexp.new("^" + name_match)
                     end
                     if name_match === package_name
-                        raw << [self.name, spec]
+                        raw << [self, spec]
                         vcs_spec =
                             begin
                                 VCSDefinition.update_raw_vcs_spec(vcs_spec, spec)
@@ -478,8 +478,8 @@ module Autoproj
             if !vcs_spec.empty?
                 expansions = Hash["PACKAGE" => package_name,
                     "PACKAGE_BASENAME" => File.basename(package_name),
-                    "AUTOPROJ_ROOT" => Autoproj.root_dir,
-                    "AUTOPROJ_CONFIG" => Autoproj.config_dir,
+                    "AUTOPROJ_ROOT" => Autoproj.workspace.root_dir,
+                    "AUTOPROJ_CONFIG" => Autoproj.workspace.config_dir,
                     "AUTOPROJ_SOURCE_DIR" => local_dir]
 
                 vcs_spec = expand(vcs_spec, expansions)
@@ -510,7 +510,7 @@ module Autoproj
             Autoproj.in_file source_file do
                 vcs_spec, raw = version_control_field(package_name, 'version_control')
                 if vcs_spec
-                    VCSDefinition.from_raw(vcs_spec, raw)
+                    VCSDefinition.from_raw(vcs_spec, raw: raw, from: self)
                 end
             end
         end
@@ -524,13 +524,14 @@ module Autoproj
             overrides.each do |file, override|
                 new_spec, new_raw_entry = 
                     Autoproj.in_file file do
-                        vcs_field(Hash['overrides' => override], package_name, 'overrides', false)
+                        vcs_field(Hash['overrides' => override],
+                                              package_name, 'overrides', false)
                     end
 
                 if new_spec
                     Autoproj.in_file file do
                         begin
-                            vcs = vcs.update(new_spec, new_raw_entry)
+                            vcs = vcs.update(new_spec, raw: new_raw_entry, from: self)
                         rescue ConfigError => e
                             raise ConfigError.new, "invalid resulting VCS specification in the overrides section for package #{package_name}: #{e.message}"
                         end
@@ -565,21 +566,18 @@ module Autoproj
 
     # Specialization of the PackageSet class for the overrides listed in autoproj/
     class LocalPackageSet < PackageSet
-        def initialize(manifest, vcs = nil)
-            if !vcs
-                if Autoproj.has_config_key?('manifest_source')
-                    vcs = VCSDefinition.from_raw(Autoproj.user_config('manifest_source'))
-                else
-                    vcs = VCSDefinition.from_raw(:type => 'local', :url => Autoproj.config_dir)
-                end
-            end
-            super(manifest, vcs)
+        def initialize(manifest)
+            super(manifest, manifest.vcs)
         end
 
         def name
             'main configuration'
         end
 
+        def vcs
+            manifest.vcs
+        end
+
         def main?
             true
         end
@@ -589,19 +587,23 @@ module Autoproj
         end
 
         def local_dir
-            Autoproj.config_dir
+            if manifest.file
+                File.dirname(manifest.file)
+            end
         end
 
         def raw_local_dir
-            Autoproj.config_dir
+            local_dir
         end
 
         def manifest_path
-            File.join(Autoproj.config_dir, "manifest")
+            manifest.file
         end
 
         def overrides_file_path
-            File.join(Autoproj.config_dir, "overrides.yml")
+            if d = local_dir
+                File.join(d, "overrides.yml")
+            end
         end
 
         def source_file
@@ -621,7 +623,7 @@ module Autoproj
         end
 
         def load_overrides
-            files = Dir.glob(File.join( Autoproj.overrides_dir, "*.yml" ) ).sort
+            files = Dir.glob(File.join( Autoproj.workspace.overrides_dir, "*.yml" ) ).sort
             overrides = files.map do |file|
                 source_data = Autoproj.in_file(file, Autoproj::YAML_LOAD_ERROR) do
                     YAML.load(File.read(file)) || Array.new

data/lib/autoproj/reporter.rb

@@ -0,0 +1,91 @@
+require 'autobuild/reporting'
+module Autoproj
+    class << self
+        attr_accessor :verbose
+        attr_reader :console
+        def silent?
+            Autobuild.silent?
+        end
+        def silent=(value)
+            Autobuild.silent = value
+        end
+    end
+    @verbose = false
+    @console = HighLine.new
+	
+
+    def self.silent(&block)
+        Autobuild.silent(&block)
+    end
+
+    def self.message(*args)
+        Autobuild.message(*args)
+    end
+
+    def self.color(*args)
+        Autobuild.color(*args)
+    end
+
+    # Displays an error message
+    def self.error(message)
+        Autobuild.error(message)
+    end
+
+    # Displays a warning message
+    def self.warn(message, *style)
+        Autobuild.warn(message, *style)
+    end
+
+    # Subclass of Autobuild::Reporter, used to display a message when the build
+    # finishes/fails.
+    class Reporter < Autobuild::Reporter
+        def error(error)
+            error_lines = error.to_s.split("\n")
+            Autoproj.message("Command failed", :bold, :red, STDERR)
+            Autoproj.message("#{error_lines.shift}", :bold, :red, STDERR)
+            error_lines.each do |line|
+                Autoproj.message line, STDERR
+            end
+        end
+        def success
+            Autoproj.message("Command finished successfully at #{Time.now}", :bold, :green)
+            if Autobuild.post_success_message
+                Autoproj.message Autobuild.post_success_message
+            end
+        end
+    end
+
+    def self.report(options = Hash.new)
+        options = Kernel.validate_options options,
+            root_dir: nil,
+            silent: false
+
+        Autobuild::Reporting.report do
+            yield
+        end
+        if !options[:silent]
+            Autobuild::Reporting.success
+        end
+
+    rescue Interrupt
+        STDERR.puts
+        STDERR.puts Autobuild.color("Interrupted by user", :red, :bold)
+        if Autobuild.debug then raise
+        else exit 1
+        end
+    rescue Exception => e
+        STDERR.puts
+        STDERR.puts Autobuild.color(e.message, :red, :bold)
+        if root_dir = options[:root_dir]
+            root_dir = /#{Regexp.quote(root_dir)}(?!\/\.gems)/
+            e.backtrace.find_all { |path| path =~ root_dir }.
+                each do |path|
+                    STDERR.puts Autobuild.color("  in #{path}", :red, :bold)
+                end
+        end
+        if Autobuild.debug then raise
+        else exit 1
+        end
+    end
+end
+

data/lib/autoproj/system.rb

@@ -1,6 +1,4 @@
 module Autoproj
-    class UserError < RuntimeError; end
-
     # OS-independent creation of symbolic links. Note that on windows, it only
     # works for directories
     def self.create_symlink(from, to)
@@ -24,6 +22,9 @@ module Autoproj
     # This is mostly useful during bootstrapping (i.e. when the search would
     # fail)
     def self.root_dir=(dir)
+        if @workspace && dir != @workspace.root_dir
+            raise WorkspaceAlreadyCreated, "cannot switch global root directory after a workspace object got created"
+        end
         @root_dir = dir
     end
 
@@ -35,90 +36,77 @@ module Autoproj
         if @root_dir
             return @root_dir
         end
-
-        path = Pathname.pwd
-        while !path.root?
-            if (path + "autoproj" + 'manifest').file?
-                break
-            end
-            path = path.parent
-        end
-
-        if path.root?
+        path = Workspace.find_root_dir(dir)
+        if !path
             raise UserError, "not in a Autoproj installation"
         end
-
-        result = path.to_s
-        # I don't know if this is still useful or not ... but it does not hurt
-        #
-        # Preventing backslashed in path, that might be confusing on some path compares
-        if Autobuild.windows?
-            result = result.gsub(/\\/,'/')
-        end
-        result
+        path
     end
 
-    # Returns the configuration directory for this autoproj installation.
-    #
-    # If the current directory is not in an autoproj installation,
-    # raises UserError.
+    # @deprecated use workspace.config_dir instead
     def self.config_dir
-        File.join(root_dir, "autoproj")
+        Autoproj.warn "#{__method__} is deprecated, use workspace.config_dir instead"
+        caller.each { |l| Autoproj.warn "  #{l}" }
+        workspace.config_dir
     end
-
-    OVERRIDES_DIR = "overrides.d"
-
-    # Returns the directory containing overrides files
-    #
-    # If the current directory is not in an autoproj installation,
-    # raises UserError.
+    # @deprecated use workspace.overrides_dir instead
     def self.overrides_dir
-        File.join(config_dir, OVERRIDES_DIR)
+        Autoproj.warn "#{__method__} is deprecated, use workspace.overrides_dir instead"
+        caller.each { |l| Autoproj.warn "  #{l}" }
+        workspace.overrides_dir
     end
-
     # @deprecated use Autobuild.find_in_path instead
     #
     # Warning: the autobuild method returns nil (instead of raising) if the
     # argument cannot be found
     def self.find_in_path(name)
+        Autoproj.warn "#{__method__} is deprecated, use Autobuild.find_in_path instead"
+        caller.each { |l| Autoproj.warn "  #{l}" }
         if path = Autobuild.find_in_path(name)
             return path
         else raise ArgumentError, "cannot find #{name} in PATH (#{ENV['PATH']})"
         end
     end
-
-    class << self
-        # The directory in which packages will be installed.
-        #
-        # If it is a relative path, it is relative to the root dir of the
-        # installation.
-        #
-        # The default is "install"
-        attr_reader :prefix
-
-        # Change the value of 'prefix'
-        def prefix=(new_path)
-            @prefix = new_path
-            Autoproj.change_option('prefix', new_path, true)
-        end
+    # @deprecated use workspace.prefix_dir instead
+    def self.prefix
+        Autoproj.warn_deprecated(__method__, 'workspace.prefix_dir')
+        workspace.prefix_dir
     end
-    @prefix = "install"
-
-    # Returns the build directory (prefix) for this autoproj installation.
-    #
-    # If the current directory is not in an autoproj installation, raises
-    # UserError.
+    # @deprecated use workspace.prefix_dir= instead
+    def self.prefix=(path)
+        Autoproj.warn_deprecated(__method__, 'workspace.prefix_dir=')
+        workspace.prefix_dir = path
+    end
+    # @deprecated use workspace.prefix_dir instead
     def self.build_dir
-        File.expand_path(Autoproj.prefix, root_dir)
+        Autoproj.warn_deprecated(__method__, 'workspace.prefix_dir')
+        workspace.prefix_dir
     end
-
-    # Returns the path to the provided configuration file.
-    #
-    # If the current directory is not in an autoproj installation, raises
-    # UserError.
+    # @deprecated compute the full path with File.join(config_dir, file)
+    #   directly instead
     def self.config_file(file)
+        Autoproj.warn_deprecated(__method__, 'compute the full path with File.join(config_dir, ...) instead')
         File.join(config_dir, file)
     end
+    # @deprecated use workspace.remotes_dir instead
+    def self.remotes_dir
+        Autoproj.warn_deprecated(__method__, 'use workspace.remotes_dir instead')
+        workspace.remotes_dir
+    end
+    # @deprecated use workspace.load or add a separate Loader object to your class
+    def self.load(package_set, *path)
+        Autoproj.warn_deprecated(
+            __method__,
+            'use workspace.load or add a separate Loader object to your class')
+        workspace.load(package_set, *path)
+    end
+    # @deprecated use workspace.load_if_present or add a separate Loader object to your class
+    def self.load_if_present(package_set, *path)
+        Autoproj.warn_deprecated(
+            __method__,
+            'use workspace.load_if_present or add a separate Loader object to your class')
+        workspace.load_if_present(package_set, *path)
+    end
 
     # Run the provided command as user
     def self.run_as_user(*args)
@@ -126,7 +114,6 @@ module Autoproj
             raise "failed to run #{args.join(" ")}"
         end
     end
-
     # Run the provided command as root, using sudo to gain root access
     def self.run_as_root(*args)
         if !system(Autobuild.tool_in_path('sudo'), *args)
@@ -134,92 +121,6 @@ module Autoproj
         end
     end
 
-    # Return the directory in which remote package set definition should be
-    # checked out
-    def self.remotes_dir
-        File.join(root_dir, ".remotes")
-    end
-
-
-    def self.env_inherit(*names)
-        Autobuild.env_inherit(*names)
-    end
-
-    # @deprecated use isolate_environment instead
-    def self.set_initial_env
-        isolate_environment
-    end
-
-    # Initializes the environment variables to a "sane default"
-    #
-    # Use this in autoproj/init.rb to make sure that the environment will not
-    # get polluted during the build.
-    def self.isolate_environment
-        Autobuild.env_inherit = false
-        Autobuild.env_push_path 'PATH', "/usr/local/bin", "/usr/bin", "/bin"
-    end
-
-    def self.prepare_environment
-        # Set up some important autobuild parameters
-        env_inherit 'PATH', 'PKG_CONFIG_PATH', 'RUBYLIB', \
-            'LD_LIBRARY_PATH', 'CMAKE_PREFIX_PATH', 'PYTHONPATH'
-        
-        env_set 'AUTOPROJ_CURRENT_ROOT', Autoproj.root_dir
-        env_set 'RUBYOPT', "-rubygems"
-        Autoproj::OSDependencies::PACKAGE_HANDLERS.each do |pkg_mng|
-            pkg_mng.initialize_environment
-        end
-    end
-
-    class << self
-        attr_writer :shell_helpers
-        def shell_helpers?; !!@shell_helpers end
-    end
-    @shell_helpers = true
-
-    # Create the env.sh script in +subdir+. In general, +subdir+ should be nil.
-    def self.export_env_sh(subdir = nil)
-        # Make sure that we have as much environment as possible
-        Autoproj::CmdLine.update_environment
-
-        filename = if subdir
-               File.join(Autoproj.root_dir, subdir, ENV_FILENAME)
-           else
-               File.join(Autoproj.root_dir, ENV_FILENAME)
-           end
-
-        shell_dir = File.expand_path(File.join("..", "..", "shell"), File.dirname(__FILE__))
-        if Autoproj.shell_helpers?
-            Autoproj.message "sourcing autoproj shell helpers"
-            Autoproj.message "add \"Autoproj.shell_helpers = false\" in autoproj/init.rb to disable"
-            Autobuild.env_source_after(File.join(shell_dir, "autoproj_sh"))
-        end
-
-        File.open(filename, "w") do |io|
-            if Autobuild.env_inherit
-                io.write <<-EOF
-                if test -n "$AUTOPROJ_CURRENT_ROOT" && test "$AUTOPROJ_CURRENT_ROOT" != "#{Autoproj.root_dir}"; then
-                    echo "the env.sh from $AUTOPROJ_CURRENT_ROOT is already loaded. Start a new shell before sourcing this one"
-                    return
-                fi
-                EOF
-            end
-            Autobuild.export_env_sh(io)
-        end
-    end
-
-    # @deprecated use Ops.loader.load or add a proper Loader object to your
-    #   class
-    def self.load(package_set, *path)
-        Ops.loader.load(package_set, *path)
-    end
-
-    # @deprecated use Ops.loader.load_if_present or add a proper Loader object
-    #   to your class
-    def self.load_if_present(package_set, *path)
-        Ops.loader.load_if_present(package_set, *path)
-    end
-
     # Look into +dir+, searching for shared libraries. For each library, display
     # a warning message if this library has undefined symbols.
     def self.validate_solib_dependencies(dir, exclude_paths = [])