autoproj 1.7.0.b1 → 1.7.0.b2

data/Rakefile

@@ -14,7 +14,7 @@ begin
             self.changes     = paragraphs_of('History.txt', 0..1).join("\n\n")
 
             extra_deps << 
-                ['autobuild',   '>= 1.5.24'] <<
+                ['autobuild',   '>= 1.5.25'] <<
                 ['rmail',   '>= 1.0.0'] <<
                 ['utilrb', '>= 1.3.3'] <<
                 ['nokogiri', '>= 1.3.3'] <<

data/bin/autoproj

@@ -1,12 +1,5 @@
 #! /usr/bin/env ruby
 
-if !ARGV.grep("--env").empty?
-    require 'autoproj/system'
-    puts File.join(Autoproj.root_dir, "env.sh")
-    exit
-end
-
-
 if RUBY_VERSION < "1.8.7"
     STDERR.puts "autoproj requires Ruby >= 1.8.7"
     exit 1

data/lib/autoproj.rb

@@ -6,6 +6,7 @@ require 'autoproj/manifest'
 require 'autoproj/osdeps'
 require 'autoproj/system'
 require 'autoproj/options'
+require 'autoproj/cmdline'
 require 'logger'
 require 'utilrb/logger'
 

data/lib/autoproj/autobuild.rb

@@ -468,6 +468,12 @@ def package(name)
     Autobuild::Package[name]
 end
 
+# Returns true if +name+ is a valid package and is neither excluded nor ignored
+# from the build
+def package_selected?(name)
+    Autoproj.manifest.package_selected?(name, false)
+end
+
 # Returns true if +name+ is a valid package and is included in the build
 def package_enabled?(name)
     Autoproj.manifest.package_enabled?(name, false)
@@ -479,3 +485,7 @@ def disable_imports_from(name)
     Autoproj.manifest.disable_imports_from(name)
 end
 
+# Moves the given package to a new subdirectory
+def move_package(name, new_dir)
+    Autoproj.manifest.move_package(name, new_dir)
+end

data/lib/autoproj/cmdline.rb

@@ -219,28 +219,28 @@ module Autoproj
             #
             # First, we allow to user to specify packages based on disk paths, so
             # resolve those
-            seen = Set.new
-            manifest.each_layout_level do |name, packages, enabled_packages|
-                packages -= seen
-
-                packages.each do |pkg_name|
-                    place =
-                        if randomize_layout?
-                            Digest::SHA256.hexdigest(pkg_name)[0, 12]
-                        else name
-                        end
+            manifest.packages.each_value do |pkg_def|
+                pkg = pkg_def.autobuild
+                pkg_name = pkg.name
+
+                layout =
+                    if randomize_layout?
+                        Digest::SHA256.hexdigest(pkg_name)[0, 12]
+                    else manifest.whereis(pkg_name)
+                    end
 
-                    srcdir  = File.join(Autoproj.root_dir, place)
-                    prefix  = File.join(Autoproj.build_dir, place)
-                    logdir  = File.join(prefix, "log")
+                place =
+                    if target = manifest.moved_packages[pkg_name]
+                        File.join(layout, target)
+                    else
+                        File.join(layout, pkg_name)
+                    end
 
-                    pkg = Autobuild::Package[pkg_name]
-                    pkg.srcdir = File.join(srcdir, pkg_name)
-                    pkg.prefix = prefix
-                    pkg.doc_target_dir = File.join(Autoproj.build_dir, 'doc', name, pkg_name)
-                    pkg.logdir = logdir
-                end
-                seen |= packages
+                pkg = Autobuild::Package[pkg_name]
+                pkg.srcdir = File.join(Autoproj.root_dir, place)
+                pkg.prefix = File.join(Autoproj.build_dir, layout)
+                pkg.doc_target_dir = File.join(Autoproj.build_dir, 'doc', name, pkg_name)
+                pkg.logdir = File.join(pkg.prefix, "log")
             end
 
             # Now call the blocks that the user defined in the autobuild files. We do it
@@ -268,20 +268,24 @@ module Autoproj
 
 
         def self.display_configuration(manifest, package_list = nil)
-            # We can't have the Manifest class load the source.yml file, as it
-            # cannot resolve all constants. So we need to do it ourselves to get
-            # the name ...
-            sets = manifest.each_package_set(false).to_a
-
-            if sets.empty?
-                Autoproj.progress("autoproj: no package sets defined in autoproj/manifest", :bold, :red)
-                return
+            # Load the manifest for packages that are already present on the
+            # file system
+            manifest.packages.each_value do |pkg|
+                if File.directory?(pkg.autobuild.srcdir)
+                    manifest.load_package_manifest(pkg.autobuild.name)
+                end
             end
 
             all_packages = Hash.new
             if package_list
-                package_sets = Set.new
+                all_selected_packages = Set.new
                 package_list.each do |name|
+                    all_selected_packages << name
+                    Autobuild::Package[name].all_dependencies(all_selected_packages)
+                end
+
+                package_sets = Set.new
+                all_selected_packages.each do |name|
                     pkg_set = manifest.definition_source(name)
                     package_sets << pkg_set
                     all_packages[name] = [manifest.package(name).autobuild, pkg_set.name]
@@ -295,6 +299,11 @@ module Autoproj
                 end
             end
 
+            if package_sets.empty?
+                Autoproj.progress("autoproj: no package sets defined in autoproj/manifest", :bold, :red)
+                return
+            end
+
             Autoproj.progress
             Autoproj.progress("autoproj: package sets", :bold)
             package_sets.each do |pkg_set|
@@ -338,6 +347,11 @@ module Autoproj
                 vcs_def = manifest.importer_definition_for(pkg.name)
                 Autoproj.progress "#{pkg.name}#{": #{pkg_manifest.short_documentation}" if pkg_manifest && pkg_manifest.short_documentation}", :bold
                 Autoproj.progress "   defined in #{pkg_set}"
+                if File.directory?(pkg.srcdir)
+                    Autoproj.progress "   checked out in #{pkg.srcdir}"
+                else
+                    Autoproj.progress "   will be checked out in #{pkg.srcdir}"
+                end
                 Autoproj.progress "   #{vcs_def.to_s}"
 
                 if !File.directory?(pkg.srcdir)
@@ -463,7 +477,13 @@ module Autoproj
                         raise ConfigError.new, "#{pkg.name} has no VCS, but is not checked out in #{pkg.srcdir}"
                     end
 
-                    Rake::Task["#{pkg.name}-import"].invoke
+                    ## COMPLETELY BYPASS RAKE HERE
+                    # The reason is that the ordering of import/prepare between
+                    # packages is not important BUT the ordering of import vs.
+                    # prepare in one package IS important: prepare is the method
+                    # that takes into account dependencies.
+                    pkg.import
+                    Rake::Task["#{pkg.name}-import"].instance_variable_set(:@already_invoked, true)
                     manifest.load_package_manifest(pkg.name)
                     pkg.resolve_optional_dependencies
                     verify_package_availability(pkg.name)
@@ -471,7 +491,8 @@ module Autoproj
 
                 current_packages.each do |pkg|
                     verify_package_availability(pkg.name)
-                    Rake::Task["#{pkg.name}-prepare"].invoke
+                    pkg.prepare
+                    Rake::Task["#{pkg.name}-prepare"].instance_variable_set(:@already_invoked, true)
 
                     # Verify that its dependencies are there, and add
                     # them to the selected_packages set so that they get
@@ -1430,6 +1451,33 @@ export PATH=$GEM_HOME/bin:$PATH
                 end
             end
         end
+
+        # This method sets up autoproj and loads the configuration available in
+        # the current autoproj installation. It is meant as a simple way to
+        # initialize an autoproj environment for standalone tools
+        #
+        # Beware, it changes the current directory to the autoproj root dir
+        def self.initialize_and_load
+            require 'autoproj/autobuild'
+            require 'open-uri'
+            require 'autoproj/cmdline'
+
+            Autoproj::CmdLine.parse_arguments(ARGV.dup, false)
+            Dir.chdir(Autoproj.root_dir)
+
+            Autoproj::CmdLine.update_os_dependencies = false
+            Autoproj::CmdLine.initialize
+            Autoproj::CmdLine.load_configuration
+            Autoproj::CmdLine.initial_package_setup
+
+            # Load the manifest for packages that are already present on the
+            # file system
+            manifest.packages.each_value do |pkg|
+                if File.directory?(pkg.autobuild.srcdir)
+                    manifest.load_package_manifest(pkg.autobuild.name)
+                end
+            end
+        end
     end
 end
 

data/lib/autoproj/manifest.rb

@@ -495,10 +495,6 @@ module Autoproj
         #
         # The returned value is a VCSDefinition object.
         def version_control_field(package_name, section_name, validate = true)
-            if !source_definition
-                raise InternalError, "source #{name} has not been loaded"
-            end
-
             urls = source_definition['urls'] || Hash.new
             urls['HOME'] = ENV['HOME']
 
@@ -779,6 +775,7 @@ module Autoproj
             @automatic_exclusions = Hash.new
             @constants_definitions = Hash.new
             @disabled_imports = Set.new
+            @moved_packages = Hash.new
 
             @constant_definitions = Hash.new
             if Autoproj.has_config_key?('manifest_source')
@@ -1055,9 +1052,6 @@ module Autoproj
         # internal name used to represent the package and +into+ the directory
         # in which the package should be checked out.
         def self.create_autobuild_package(vcs, text_name, into)
-            if !into
-                raise
-            end
             importer     = vcs.create_autobuild_importer
             return if !importer # updates have been disabled by using the 'none' type
 
@@ -1071,9 +1065,6 @@ module Autoproj
         #
         # See create_autobuild_package for informations about the arguments.
         def self.update_package_set(vcs, text_name, into)
-            if !into
-                raise
-            end
             fake_package = create_autobuild_package(vcs, text_name, into)
             fake_package.import
 
@@ -1255,12 +1246,16 @@ module Autoproj
         #
         # If recursive is false, yields only the packages at this level.
         # Otherwise, return all packages.
-        def layout_packages(layout_def, recursive, validate = true)
-            result = []
+        def layout_packages(result, layout_def, recursive, validate = true)
             layout_def.each do |value|
                 if !value.kind_of?(Hash) # sublayout
                     begin
-                        result.concat(resolve_package_set(value))
+                        pkgs = resolve_package_set(value)
+                        pkgs.each do |p|
+                            result << p
+                            Autobuild::Package[p].all_dependencies(result)
+                        end
+
                     rescue ConfigError
                         raise if validate
                     end
@@ -1269,7 +1264,7 @@ module Autoproj
 
             if recursive
                 each_sublayout(layout_def) do |sublayout_name, sublayout_def|
-                    result.concat(layout_packages(sublayout_def, true))
+                    layout_packages(result, sublayout_def, true)
                 end
             end
 
@@ -1286,36 +1281,6 @@ module Autoproj
             end
         end
 
-        # Looks into the layout setup in the manifest, and yields each layout
-        # and sublayout in order
-        def each_layout_level(selection = nil, layout_name = '/', layout_def = data['layout'], &block)
-            if !layout_def
-                yield(layout_name, default_packages, default_packages)
-                return nil
-            end
-
-            selection = selection.to_set if selection
-
-            # First of all, do the packages at this level
-            packages = layout_packages(layout_def, false)
-            # Remove excluded packages
-            packages.delete_if { |pkg_name| excluded?(pkg_name) }
-
-            if selection
-                selected_packages = packages.find_all { |pkg_name| selection.include?(pkg_name) }
-            else
-                selected_packages = packages.dup
-            end
-            if !packages.empty?
-                yield(layout_name, packages.to_set, selected_packages.to_set)
-            end
-
-            # Now, enumerate the sublayouts
-            each_sublayout(layout_def) do |subname, sublayout|
-                each_layout_level(selection, "#{layout_name}#{subname}/", sublayout, &block)
-            end
-        end
-
         # Returns the set of package names that are explicitely listed in the
         # layout, minus the excluded and ignored ones
         def all_layout_packages(validate = true)
@@ -1336,12 +1301,11 @@ module Autoproj
 
         # Returns true if +name+ is a valid package and is included in the build
         #
-        # If +validate+ is true, the layout will have to be well-defined. It can
-        # therefore be used only after all sources have been successfully
-        # loaded.
+        # If +validate+ is true, the method will raise ArgumentError if the
+        # package does not exists. 
         #
-        # If it is false, non-defined packages/package sets in the layout will
-        # simply be ignored
+        # If it is false, the method will simply return false on non-defined
+        # packages 
         def package_enabled?(name, validate = true)
             if !Autobuild::Package[name]
                 if validate
@@ -1353,11 +1317,25 @@ module Autoproj
             !excluded?(name)
         end
 
+        # Returns true if +name+ is a valid package and is neither excluded from
+        # the build, nor ignored from the build
+        #
+        # If +validate+ is true, the method will raise ArgumentError if the
+        # package does not exists. 
+        #
+        # If it is false, the method will simply return false on non-defined
+        # packages 
+        def package_selected?(name, validate = true)
+            if package_enabled?(name)
+                !ignored?(name)
+            end
+        end
+
         # Returns the set of packages that should be built if the user does not
         # specify any on the command line
         def default_packages(validate = true)
             names = if layout = data['layout']
-                        layout_packages(layout, true, validate)
+                        layout_packages(Set.new, layout, true, validate)
                     else
                         # No layout, all packages are selected
                         all_packages
@@ -1367,15 +1345,27 @@ module Autoproj
             names.to_set
         end
 
+        def search_layout(layout_level, layout_data, *names)
+            layout_data.each do |value|
+                if value.kind_of?(Hash)
+                    each_sublayout(value) do |subname, subdef|
+                        if result = search_layout("#{layout_level}/#{subname}", subdef)
+                            return result
+                        end
+                    end
+
+                elsif names.include?(value)
+                    return layout_level
+                end
+            end
+            nil
+        end
+
         # Returns the package directory for the given package name
         def whereis(package_name)
             Autoproj.in_file(self.file) do
-                each_layout_level do |layout_name, packages, _|
-                    if packages.include?(package_name)
-                        return layout_name
-                    end
-                end
-                raise ArgumentError, "cannot find #{package_name} in the layout section"
+                set_name = definition_source(package_name).name
+                return (search_layout("/", (data['layout'] || Hash.new), package_name, set_name) || "/")
             end
         end
 
@@ -1501,23 +1491,13 @@ module Autoproj
                 !packages.empty? || !sources.empty?
             end
 
-            # Now, search for layout names
-            each_layout_level(nil) do |layout_name, packages, _|
-                selected_packages.each do |sel|
-                    if layout_name[0..-1] =~ Regexp.new("#{sel}\/?$")
-                        expanded_packages |= packages.to_set
-                    end
-                end
-            end
-
             # Finally, check for package source directories
             all_packages = self.all_package_names
             selected_packages.each do |sel|
-                match_dir      = Regexp.new("^#{Regexp.quote(sel)}")
                 match_pkg_name = Regexp.new(Regexp.quote(sel))
                 all_packages.each do |pkg_name|
                     pkg = Autobuild::Package[pkg_name]
-                    if pkg_name =~ match_pkg_name || pkg.srcdir =~ match_dir
+                    if pkg_name =~ match_pkg_name || sel =~ Regexp.new("^#{Regexp.quote(pkg.srcdir)}") || pkg.srcdir =~ Regexp.new("^#{Regexp.quote(sel)}")
                         # Check-out packages that are not in the manifest only
                         # if they are explicitely selected
                         if pkg_name != sel && pkg.srcdir != sel && !all_layout_packages.include?(pkg.name)
@@ -1533,6 +1513,20 @@ module Autoproj
             expanded_packages.delete_if { |pkg_name| excluded?(pkg_name) || ignored?(pkg_name) }
             expanded_packages.to_set
         end
+
+        attr_reader :moved_packages
+
+        # Moves the given package name from its current subdirectory to the
+        # provided one.
+        #
+        # For instance, for a package called drivers/xsens_imu
+        #
+        #   move("drivers/xsens_imu", "data_acquisition")
+        #
+        # will move the package into data_acquisition/xsens_imu
+        def move_package(package_name, new_dir)
+            moved_packages[package_name] = File.join(new_dir, File.basename(package_name))
+        end
     end
 
     class << self

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "1.7.0.b1"
+    VERSION = "1.7.0.b2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: autoproj
 version: !ruby/object:Gem::Version 
-  hash: 6629751
+  hash: 6629748
   prerelease: true
   segments: 
   - 1
   - 7
   - 0
-  - b1
-  version: 1.7.0.b1
+  - b2
+  version: 1.7.0.b2
 platform: ruby
 authors: 
 - Sylvain Joyeux
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 +01:00
+date: 2010-11-24 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,12 +27,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 51
+        hash: 49
         segments: 
         - 1
         - 5
-        - 24
-        version: 1.5.24
+        - 25
+        version: 1.5.25
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency