autoproj 1.7.12.rc1 → 1.7.12.rc2

data/bin/autoproj

@@ -47,6 +47,14 @@ end
 
 Autoproj::OSDependencies.autodetect_ruby
 
+# Check the first element of ARGV. If a tool called autoproj-VALUE exists, just
+# pass the hand to it
+prefix = File.expand_path(__FILE__)
+if File.file?("#{prefix}-#{ARGV.first}")
+    binary = "#{prefix}-#{ARGV.shift}"
+    exec(binary, *ARGV)
+end
+
 # Find the autoproj root dir
 report do
     selected_packages =
@@ -217,20 +225,6 @@ EOTEXT
         Autoproj::CmdLine.build_packages(command_line_selection, all_enabled_packages)
     elsif Autoproj::CmdLine.build? 
         Autoproj::CmdLine.build_packages(command_line_selection, all_enabled_packages)
-
-        # Now, do some sanity checks on the result
-        prefixes = all_enabled_packages.inject(Set.new) do |set, pkg_name|
-            set << Autobuild::Package[pkg_name].prefix
-        end
-
-        Autoproj.progress
-        Autoproj.progress "checking for undefined symbols in installed libraries", :bold
-        prefixes.each do |prefix|
-            libdir = File.join(prefix, "lib")
-            if File.directory?(libdir)
-                Autoproj.validate_solib_dependencies(libdir)
-            end
-        end
     end
 
     if Autoproj::CmdLine.update_envsh?

data/lib/autoproj.rb

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

data/lib/autoproj/cmdline.rb

@@ -348,6 +348,13 @@ module Autoproj
                     package_sets << pkg_set
                     all_packages[name] = [manifest.package(name).autobuild, pkg_set.name]
                 end
+
+                metapackages = Set.new
+                manifest.metapackages.each_value do |metap|
+                    if package_list.any? { |pkg_name| metap.include?(pkg_name) }
+                        metapackages << metap
+                    end
+                end
             else
                 package_sets = manifest.each_package_set
                 package_sets.each do |pkg_set|
@@ -355,6 +362,8 @@ module Autoproj
                         all_packages[pkg.name] = [pkg, pkg_set.name]
                     end
                 end
+
+                metapackages = manifest.metapackages.values
             end
 
             if package_sets.empty?
@@ -364,7 +373,7 @@ module Autoproj
 
             Autoproj.progress
             Autoproj.progress("autoproj: package sets", :bold)
-            package_sets.each do |pkg_set|
+            package_sets.sort_by(&:name).each do |pkg_set|
                 next if pkg_set.empty?
                 if pkg_set.imported_from
                     Autoproj.progress "#{pkg_set.name} (imported by #{pkg_set.imported_from.name})"
@@ -393,6 +402,13 @@ module Autoproj
                 Autoproj.progress "  defines: #{set_packages.map(&:name).join(", ")}"
             end
 
+            Autoproj.progress
+            Autoproj.progress("autoproj: metapackages", :bold)
+            metapackages.sort_by(&:name).each do |metap|
+                Autoproj.progress "#{metap.name}"
+                Autoproj.progress "  includes: #{metap.packages.map(&:name).sort.join(", ")}"
+            end
+
             packages_not_present = []
 
             Autoproj.progress
@@ -412,7 +428,7 @@ module Autoproj
                 else
                     Autoproj.progress "   tags: #{pkg.tags.to_a.sort.join(", ")}"
                 end
-                Autoproj.progress "   defined in #{pkg_set}"
+                Autoproj.progress "   defined in package set #{pkg_set}"
                 if File.directory?(pkg.srcdir)
                     Autoproj.progress "   checked out in #{pkg.srcdir}"
                 else
@@ -982,6 +998,10 @@ where 'mode' is one of:
                 @only_config = true
 
             when "switch-config"
+                if Dir.pwd.start_with?(Autoproj.remotes_dir) || Dir.pwd.start_with?(Autoproj.config_dir)
+                    raise ConfigError, "you cannot run autoproj switch-config from autoproj's configuration directory or one of its subdirectories"
+                end
+
                 # We must switch to the root dir first, as it is required by the
                 # configuration switch code. This is acceptable as long as we
                 # quit just after the switch
@@ -1187,7 +1207,7 @@ where 'mode' is one of:
         def self.switch_config(*args)
             Autoproj.load_config
             if Autoproj.has_config_key?('manifest_source')
-                vcs = Autoproj.normalize_vcs_definition(Autoproj.user_config('manifest_source'))
+                vcs = VCSDefinition.from_raw(Autoproj.user_config('manifest_source'))
             end
 
             if args.first =~ /^(\w+)=/
@@ -1209,7 +1229,8 @@ where 'mode' is one of:
                     opt_name, opt_value = opt.split('=')
                     vcs_def[opt_name] = opt_value
                 end
-                Autoproj.normalize_vcs_definition(vcs_def)
+                # Validate the VCS definition, but save the hash as-is
+                VCSDefinition.from_raw(vcs_def)
                 Autoproj.change_option "manifest_source", vcs_def.dup, true
                 Autoproj.save_config
                 true
@@ -1238,7 +1259,7 @@ where 'mode' is one of:
                 vcs_def[name] = value
             end
 
-            vcs = Autoproj.normalize_vcs_definition(vcs_def)
+            vcs = VCSDefinition.from_raw(vcs_def)
 
             # Install the OS dependencies required for this VCS
 	    Autoproj::OSDependencies.define_osdeps_mode_option
@@ -1276,7 +1297,7 @@ where 'mode' is one of:
                 vcs_def[opt_name] = opt_val
             end
             # Validate the option hash, just in case
-            Autoproj.normalize_vcs_definition(vcs_def)
+            VCSDefinition.from_raw(vcs_def)
             # Save the new options
             Autoproj.change_option "manifest_source", vcs_def.dup, true
             Autoproj.save_config

data/lib/autoproj/manifest.rb

@@ -60,40 +60,186 @@ module Autoproj
         @env_inherit |= names
     end
 
-    # Resets the value of the given environment variable to the given
+    # Sets an environment variable
+    #
+    # This sets (or resets) the environment variable +name+ to the given value.
+    # If multiple values are given, they are joined with ':'
+    #
+    # The values can contain configuration parameters using the
+    # $CONF_VARIABLE_NAME syntax.
     def self.env_set(name, *value)
         Autobuild.env_clear(name)
         env_add(name, *value)
     end
+
+    # Adds new values to a given environment variable
+    #
+    # Adds the given value(s) to the environment variable named +name+. The
+    # values are added using the ':' marker.
+    #
+    # The values can contain configuration parameters using the
+    # $CONF_VARIABLE_NAME syntax.
     def self.env_add(name, *value)
         value = value.map { |v| expand_environment(v) }
         Autobuild.env_add(name, *value)
     end
+
+    # Sets an environment variable which is a path search variable (such as
+    # PATH, RUBYLIB, PYTHONPATH)
+    #
+    # This sets (or resets) the environment variable +name+ to the given value.
+    # If multiple values are given, they are joined with ':'. Unlike env_set,
+    # duplicate values will be removed.
+    #
+    # The values can contain configuration parameters using the
+    # $CONF_VARIABLE_NAME syntax.
     def self.env_set_path(name, *value)
         Autobuild.env_clear(name)
         env_add_path(name, *value)
     end
+
+    # Adds new values to a given environment variable, which is a path search
+    # variable (such as PATH, RUBYLIB, PYTHONPATH)
+    #
+    # Adds the given value(s) to the environment variable named +name+. The
+    # values are added using the ':' marker. Unlike env_set, duplicate values
+    # will be removed.
+    #
+    # The values can contain configuration parameters using the
+    # $CONF_VARIABLE_NAME syntax.
+    #
+    # This is usually used in package configuration blocks to add paths
+    # dependent on the place of install, such as
+    #
+    #   cmake_package 'test' do |pkg|
+    #     Autoproj.env_add_path 'RUBYLIB', File.join(pkg.srcdir, 'bindings', 'ruby')
+    #   end
     def self.env_add_path(name, *value)
         value = value.map { |v| expand_environment(v) }
         Autobuild.env_add_path(name, *value)
     end
 
+    # Representation of a VCS definition contained in a source.yml file or in
+    # autoproj/manifest
     class VCSDefinition
         attr_reader :type
         attr_reader :url
         attr_reader :options
 
-        def initialize(type, url, options)
+        # The original spec in hash form. Set if this VCSDefinition object has
+        # been created using VCSDefinition.from_raw
+        attr_reader :raw
+
+        def initialize(type, url, options, raw = nil)
+            if raw && !raw.respond_to?(:to_ary)
+                raise ArgumentError, "wrong format for the raw field (#{raw.inspect})"
+            end
+
             @type, @url, @options = type, url, options
             if type != "none" && type != "local" && !Autobuild.respond_to?(type)
                 raise ConfigError.new, "version control #{type} is unknown to autoproj"
             end
+            @raw = raw
         end
 
         def local?
             @type == 'local'
         end
 
+        # Updates the VCS specification +old+ by the information contained in
+        # +new+
+        #
+        # Both +old+ and +new+ are supposed to be in hash form. It is assumed
+        # that +old+ has already been normalized by a call to
+        # Autoproj.vcs_definition_to_hash. +new+ can be in "raw" form.
+        def self.update_raw_vcs_spec(old, new)
+            new = vcs_definition_to_hash(new)
+            if new.has_key?(:type) && (old[:type] != new[:type])
+                # The type changed. We replace the old definition by the new one
+                # completely, and we make sure that the new definition is valid
+                from_raw(new)
+                new
+            else
+                old.merge(new)
+            end
+        end
+
+        # Normalizes a VCS definition contained in a YAML file into a hash
+        #
+        # It handles custom source handler expansion, as well as the bad habit
+        # of forgetting a ':' at the end of a line:
+        #
+        #   - package_name
+        #     branch: value
+        def self.vcs_definition_to_hash(spec)
+            options = Hash.new
+
+            plain = Array.new
+            filtered_spec = Hash.new
+            spec.each do |key, value|
+                keys = key.to_s.split(/\s+/)
+                plain.concat(keys[0..-2])
+                filtered_spec[keys[-1].to_sym] = value
+            end
+            spec = filtered_spec
+
+            if plain.size > 1
+                raise ConfigError.new, "invalid syntax"
+            elsif plain.size == 1
+                short_url = plain.first
+                vcs, *url = short_url.split(':')
+
+                # Check if VCS is a known version control system or source handler
+                # shortcut. If it is not, look for a local directory called
+                # short_url
+                if Autobuild.respond_to?(vcs)
+                    spec.merge!(:type => vcs, :url => url.join(':'))
+                elsif Autoproj.has_source_handler?(vcs)
+                    spec = Autoproj.call_source_handler(vcs, url.join(':'), spec)
+                else
+                    source_dir = File.expand_path(File.join(Autoproj.config_dir, short_url))
+                    if !File.directory?(source_dir)
+                        raise ConfigError.new, "'#{spec.inspect}' is neither a remote source specification, nor a local source definition"
+                    end
+                    spec.merge!(:type => 'local', :url => source_dir)
+                end
+            end
+
+            spec, vcs_options = Kernel.filter_options spec, :type => nil, :url => nil
+            spec.merge!(vcs_options)
+            if !spec[:url]
+                # Verify that none of the keys are source handlers. If it is the
+                # case, convert
+                filtered_spec = Hash.new
+                spec.dup.each do |key, value|
+                    if Autoproj.has_source_handler?(key)
+                        spec.delete(key)
+                        spec = Autoproj.call_source_handler(key, value, spec)
+                        break
+                    end
+                end
+            end
+
+            spec
+        end
+
+        # Autoproj configuration files accept VCS definitions in three forms:
+        #  * as a plain string, which is a relative/absolute path
+        #  * as a plain string, which is a vcs_type:url string
+        #  * as a hash
+        #
+        # This method returns the VCSDefinition object matching one of these
+        # specs. It raises ConfigError if there is no type and/or url
+        def self.from_raw(spec, raw_spec = [[nil, spec]])
+            spec = vcs_definition_to_hash(spec)
+            if !(spec[:type] && (spec[:type] == 'none' || spec[:url]))
+                raise ConfigError.new, "the source specification #{spec.inspect} misses either the VCS type or an URL"
+            end
+
+            spec, vcs_options = Kernel.filter_options spec, :type => nil, :url => nil
+            return VCSDefinition.new(spec[:type], spec[:url], vcs_options, raw_spec)
+        end
+
         def ==(other_vcs)
             return false if !other_vcs.kind_of?(VCSDefinition)
             if local?
@@ -117,6 +263,10 @@ module Autoproj
             url
         end
 
+        # Returns a properly configured instance of a subclass of
+        # Autobuild::Importer that match this VCS definition
+        #
+        # Returns nil if the VCS type is 'none'
         def create_autobuild_importer
             return if type == "none"
 
@@ -124,6 +274,7 @@ module Autoproj
             Autobuild.send(type, url, options)
         end
 
+        # Returns a pretty representation of this VCS definition
         def to_s 
             if type == "none"
                 "none"
@@ -186,74 +337,11 @@ module Autoproj
         @custom_source_handlers[name.to_s] = lambda(&handler)
     end
 
-    def self.vcs_definition_to_hash(spec)
-        options = Hash.new
-
-        plain = Array.new
-        filtered_spec = Hash.new
-        spec.each do |key, value|
-            keys = key.to_s.split(/\s+/)
-            plain.concat(keys[0..-2])
-            filtered_spec[keys[-1].to_sym] = value
-        end
-        spec = filtered_spec
-
-        if plain.size > 1
-            raise ConfigError.new, "invalid syntax"
-        elsif plain.size == 1
-            short_url = plain.first
-            vcs, *url = short_url.split(':')
-
-            # Check if VCS is a known version control system or source handler
-            # shortcut. If it is not, look for a local directory called
-            # short_url
-            if Autobuild.respond_to?(vcs)
-                spec.merge!(:type => vcs, :url => url.join(':'))
-            elsif has_source_handler?(vcs)
-                spec = call_source_handler(vcs, url.join(':'), spec)
-            else
-                source_dir = File.expand_path(File.join(Autoproj.config_dir, short_url))
-                if !File.directory?(source_dir)
-                    raise ConfigError.new, "'#{spec.inspect}' is neither a remote source specification, nor a local source definition"
-                end
-                spec.merge!(:type => 'local', :url => source_dir)
-            end
-        end
-
-        spec, vcs_options = Kernel.filter_options spec, :type => nil, :url => nil
-        spec.merge!(vcs_options)
-        if !spec[:url]
-            # Verify that none of the keys are source handlers. If it is the
-            # case, convert
-            filtered_spec = Hash.new
-            spec.dup.each do |key, value|
-                if has_source_handler?(key)
-                    spec.delete(key)
-                    spec = call_source_handler(key, value, spec)
-                    break
-                end
-            end
-        end
-
-        spec
-    end
-
-    # Autoproj configuration files accept VCS definitions in three forms:
-    #  * as a plain string, which is a relative/absolute path
-    #  * as a plain string, which is a vcs_type:url string
-    #  * as a hash
+    # Does a non-recursive expansion in +data+ of configuration variables
+    # ($VAR_NAME) listed in +definitions+
     #
-    # This method normalizes the three forms into a VCSDefinition object
-    def self.normalize_vcs_definition(spec)
-        spec = vcs_definition_to_hash(spec)
-        if !(spec[:type] && (spec[:type] == 'none' || spec[:url]))
-            raise ConfigError.new, "the source specification #{spec.inspect} misses either the VCS type or an URL"
-        end
-
-        spec, vcs_options = Kernel.filter_options spec, :type => nil, :url => nil
-        return VCSDefinition.new(spec[:type], spec[:url], vcs_options)
-    end
-
+    # If the values listed in +definitions+ also contain configuration
+    # variables, they do not get expanded
     def self.single_expansion(data, definitions)
         if !data.respond_to?(:to_str)
             return data
@@ -300,6 +388,10 @@ module Autoproj
         end
     end
 
+    # Resolves all possible variable references from +constants+
+    #
+    # I.e. replaces variables by their values, so that no value in +constants+
+    # refers to variables defined in +constants+
     def self.resolve_constant_definitions(constants)
         constants = constants.dup
         constants['HOME'] = ENV['HOME']
@@ -319,6 +411,7 @@ module Autoproj
     # dependencies that are provided by the operating system (.osdeps file).
     class PackageSet
         attr_reader :manifest
+
         # The VCSDefinition object that defines the version control holding
         # information for this source. Local package sets (i.e. the ones that are not
         # under version control) use the 'local' version control name. For them,
@@ -402,15 +495,15 @@ module Autoproj
 
         # Create a PackageSet instance from its description as found in YAML
         # configuration files
-        def self.from_spec(manifest, spec, load_description)
-            spec = Autoproj.vcs_definition_to_hash(spec)
+        def self.from_spec(manifest, raw_spec, load_description)
+            spec = VCSDefinition.vcs_definition_to_hash(raw_spec)
             options, vcs_spec = Kernel.filter_options spec, :auto_imports => true
 
             # Look up for short notation (i.e. not an explicit hash). It is
             # 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)
-            vcs_def  = Autoproj.normalize_vcs_definition(vcs_spec)
+            vcs_def  = VCSDefinition.from_raw(vcs_spec, [[nil, raw_spec]])
 
             source = PackageSet.new(manifest, vcs_def)
             source.auto_imports = options[:auto_imports]
@@ -428,6 +521,12 @@ module Autoproj
             source
         end
 
+        # Returns a string that uniquely represents the version control
+        # information for this package set.
+        #
+        # I.e. for two package sets set1 and set2, if set1.repository_id ==
+        # set2.repository_id, it means that both package sets are checked out
+        # from exactly the same source.
         def repository_id
             if local?
                 local_dir
@@ -621,6 +720,7 @@ module Autoproj
                 end
             end
 
+            raw = []
             vcs_spec = Hash.new
 
             if all_vcs
@@ -659,7 +759,7 @@ module Autoproj
                             if spec == "none"
                                 spec = { :type => "none" }
                             else
-                                raise ConfigError.new, "invalid VCS specification '#{name}: #{spec}'"
+                                raise ConfigError.new, "invalid VCS specification in the #{section_name} section '#{name}: #{spec}'"
                             end
                         end
                     end
@@ -669,7 +769,13 @@ module Autoproj
                         name_match = Regexp.new("^" + name_match)
                     end
                     if name_match === package_name
-                        vcs_spec = vcs_spec.merge(spec)
+                        raw << [self.name, spec]
+                        vcs_spec =
+                            begin
+                                VCSDefinition.update_raw_vcs_spec(vcs_spec, spec)
+                            rescue ConfigError => e
+                                raise ConfigError.new, "invalid VCS definition in the #{section_name} section for '#{name}': #{e.message}", e.backtrace
+                            end
                     end
                 end
             end
@@ -682,7 +788,6 @@ module Autoproj
                     "AUTOPROJ_SOURCE_DIR" => local_dir]
 
                 vcs_spec = expand(vcs_spec, expansions)
-                vcs_spec = Autoproj.vcs_definition_to_hash(vcs_spec)
                 vcs_spec.dup.each do |name, value|
                     vcs_spec[name] = expand(value, expansions)
                 end
@@ -690,9 +795,15 @@ module Autoproj
                 # If required, verify that the configuration is a valid VCS
                 # configuration
                 if validate
-                    Autoproj.normalize_vcs_definition(vcs_spec)
+                    begin
+                        VCSDefinition.from_raw(vcs_spec)
+                    rescue ConfigError => e
+                        raise ConfigError.new, "invalid resulting VCS definition for package #{package_name}: #{e.message}", e.backtrace
+                    end
                 end
-                vcs_spec
+                return vcs_spec, raw
+            else
+                return nil, []
             end
         end
 
@@ -701,9 +812,11 @@ module Autoproj
         #
         # The definition is an instance of VCSDefinition
         def importer_definition_for(package_name)
-            vcs_spec = version_control_field(package_name, 'version_control')
-            if vcs_spec
-                Autoproj.normalize_vcs_definition(vcs_spec)
+            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)
+                end
             end
         end
 
@@ -733,7 +846,7 @@ module Autoproj
     # Specialization of the PackageSet class for the overrides listed in autoproj/
     class LocalPackageSet < PackageSet
         def initialize(manifest)
-            super(manifest, Autoproj.normalize_vcs_definition(:type => 'local', :url => Autoproj.config_dir))
+            super(manifest, VCSDefinition.from_raw(:type => 'local', :url => Autoproj.config_dir))
         end
 
         def name
@@ -752,7 +865,7 @@ module Autoproj
         # Returns the default importer for this package set
         def default_importer
             importer_definition_for('default') ||
-                Autoproj.normalize_vcs_definition(:type => 'none')
+                VCSDefinition.from_raw(:type => 'none')
         end
 
         def raw_description_file
@@ -782,6 +895,7 @@ module Autoproj
         attr_reader :file
         def setup?; !!@setup end
         attr_writer :setup
+        attr_accessor :vcs
 
         def initialize(autobuild, package_set, file)
             @autobuild, @package_set, @file =
@@ -935,7 +1049,7 @@ module Autoproj
 
             @constant_definitions = Hash.new
             if Autoproj.has_config_key?('manifest_source')
-                @vcs = Autoproj.normalize_vcs_definition(Autoproj.user_config('manifest_source'))
+                @vcs = VCSDefinition.from_raw(Autoproj.user_config('manifest_source'))
             end
 	end
 
@@ -1193,7 +1307,7 @@ module Autoproj
             @package_sets = each_package_set(false).to_a
             @package_sets.each do |pkg_set|
                 @metapackages[pkg_set.name] ||= Metapackage.new(pkg_set.name)
-                @metapackages["#{pkg_set.name}.all"] ||= Metapackage.new(pkg_set.name)
+                @metapackages["#{pkg_set.name}.all"] ||= Metapackage.new("#{pkg_set.name}.all")
             end
         end
 
@@ -1402,16 +1516,25 @@ module Autoproj
 
             # Get the version control information from the package source. There
             # must be one
-            vcs_spec = package_source.version_control_field(package_name, 'version_control')
+            vcs_spec, raw = Autoproj.in_file package_source.source_file do
+                package_source.version_control_field(package_name, 'version_control')
+            end
             return if !vcs_spec
 
             sources.each do |src|
-                overrides_spec = src.version_control_field(package_name, 'overrides', false)
+                overrides_spec, raw_additional = src.version_control_field(package_name, 'overrides', false)
+                raw = raw.concat(raw_additional)
                 if overrides_spec
-                    vcs_spec.merge!(overrides_spec)
+                    vcs_spec = Autoproj.in_file src.source_file do
+                        begin
+                            VCSDefinition.update_raw_vcs_spec(vcs_spec, overrides_spec)
+                        rescue ConfigError => e
+                            raise ConfigError.new, "invalid resulting VCS specification in the overrides section for package #{package_name}: #{e.message}"
+                        end
+                    end
                 end
             end
-            Autoproj.normalize_vcs_definition(vcs_spec)
+            VCSDefinition.from_raw(vcs_spec, raw)
         end
 
         # Sets up the package importers based on the information listed in
@@ -1437,6 +1560,7 @@ module Autoproj
 
                 if vcs
                     Autoproj.add_build_system_dependency vcs.type
+                    pkg.vcs = vcs
                     pkg.autobuild.importer = vcs.create_autobuild_importer
                 else
                     raise ConfigError.new, "source #{pkg.package_set.name} defines #{pkg.autobuild.name}, but does not provide a version control definition for it"
@@ -1450,6 +1574,16 @@ module Autoproj
             each_package_set(false).find { |set| set.name == name }
         end
 
+        # Returns the PackageSet object for the given package set, or raises
+        # ArgumentError if none exists with that name
+        def package_set(name)
+            set = each_package_set(false).find { |set| set.name == name }
+            if !set
+                raise ArgumentError, "no package set called #{name} exists"
+            end
+            set
+        end
+
         # +name+ can either be the name of a source or the name of a package. In
         # the first case, we return all packages defined by that source. In the
         # latter case, we return the singleton array [name]

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "1.7.12.rc1"
+    VERSION = "1.7.12.rc2"
 end

data/shell/autoproj_bash

@@ -1,6 +1,6 @@
 function acd {
     local pkg_path
-    pkg_path=$(autolocate $1)
+    pkg_path=$(autoproj locate $1)
 
     if [ $? != 0 ]; then
       return 1

data/shell/autoproj_zsh

@@ -1,6 +1,6 @@
 function acd {
     local pkg_path
-    pkg_path=$(autolocate $1)
+    pkg_path=$(autoproj locate $1)
 
     if [ $? != 0 ]; then
       return 1

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: autoproj
 version: !ruby/object:Gem::Version 
-  hash: 15424039
+  hash: 15424033
   prerelease: 7
   segments: 
   - 1
   - 7
   - 12
   - rc
-  - 1
-  version: 1.7.12.rc1
+  - 2
+  version: 1.7.12.rc2
 platform: ruby
 authors: 
 - Sylvain Joyeux
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-14 00:00:00 Z
+date: 2011-08-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: autobuild