autoproj 2.0.0.rc37 → 2.0.0.rc38

data/lib/autoproj/query.rb

@@ -54,6 +54,14 @@ class Query
         attr_predicate :use_dir_prefix?
         attr_predicate :partial?
 
+        class All
+            def match(pkg); true end
+        end
+
+        def self.all
+            All.new
+        end
+
         def initialize(fields, value, partial)
             @fields = fields
             @value = value
@@ -158,7 +166,11 @@ def self.parse_query(query)
                     Query.parse(str)
                 end
             end
-            And.new(query)
+            if query.size == 1
+                query.first
+            else
+                And.new(query)
+            end
         end
 
         # Match object that combines multiple matches using a logical OR

data/lib/autoproj/system.rb

@@ -112,8 +112,8 @@ def self.run_as_user(*args)
         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)
+    def self.run_as_root(*args, env: self.workspace.env)
+        if !system(Autobuild.tool_in_path('sudo', env: env), *args)
             raise "failed to run #{args.join(" ")} as root"
         end
     end

data/lib/autoproj/test.rb

@@ -4,6 +4,7 @@
     begin
         require 'simplecov'
         SimpleCov.start do
+            command_name 'master'
             add_filter "/test/"
         end
     rescue LoadError
@@ -18,6 +19,7 @@
 require 'minitest/autorun'
 require 'autoproj'
 require 'flexmock/minitest'
+FlexMock.partials_are_based = true
 require 'minitest/spec'
 
 if ENV['TEST_ENABLE_PRY'] != '0'
@@ -40,15 +42,27 @@ module Autoproj
     #   end
     #
     module SelfTest
+        # Define package managers for the next workspace created by {#ws_create}
+        #
+        # Use {#ws_define_package_manager}
+        #
+        # Two package managers called 'os' and 'os_indep' are always created,
+        # 'os' is used as the os package manager.
+        #
+        # @return [Hash<String,PackageManagers::Manager>]
+        attr_reader :ws_package_managers
+        # The workspace created by the last call to #ws_create
         attr_reader :ws
 
         def setup
+            FileUtils.rm_rf fixture_gem_home
             @gem_server_pid = nil
             @tmpdir = Array.new
-            @ws = Workspace.new('/test/dir')
-            ws.load_config
-            Autoproj.workspace = ws
-            FileUtils.rm_rf fixture_gem_home
+            @ws = nil
+            @ws_package_managers = Hash.new
+            Autobuild.logdir = make_tmpdir
+            ws_define_package_manager 'os'
+            ws_define_package_manager 'os_indep'
 
             super
         end
@@ -59,6 +73,7 @@ def teardown
                 FileUtils.remove_entry_secure dir
             end
             Autobuild::Package.clear
+            Autoproj.silent = false
 
             if @gem_server_pid
                 stop_gem_server
@@ -68,12 +83,11 @@ def teardown
         end
 
         def create_bootstrap
-            dir = make_tmpdir
-            require 'autoproj/ops/main_config_switcher'
-            FileUtils.cp_r Ops::MainConfigSwitcher::MAIN_CONFIGURATION_TEMPLATE, File.join(dir, 'autoproj')
-            FileUtils.mkdir_p File.join(dir, '.autoproj')
-            FileUtils.touch File.join(dir, '.autoproj', 'config.yml')
-            Workspace.new(dir)
+            ws_create
+        end
+
+        def skip_long_tests?
+            ENV['AUTOPROJ_SKIP_LONG_TESTS'] == '1'
         end
 
         def make_tmpdir
@@ -140,8 +154,13 @@ def invoke_test_script(name, *arguments,
             end
             result = nil
             stdout, stderr = capture_subprocess_io do
+                default_env = Hash[
+                    'TEST_COMMAND_NAME' => self.to_s.gsub(/[^\w]/, '_'),
+                    'PACKAGE_BASE_DIR' => package_base_dir,
+                    'RUBY' => Gem.ruby
+                ]
                 result = Bundler.clean_system(
-                    Hash['PACKAGE_BASE_DIR' => package_base_dir, 'RUBY' => Gem.ruby].merge(env),
+                    default_env.merge(env),
                     script, *arguments, in: :close, **Hash[chdir: dir].merge(system_options))
             end
 
@@ -200,6 +219,16 @@ def stop_gem_server
             @gem_server_pid = nil
         end
 
+        def capture_deprecation_message(&block)
+            level = Autoproj.warn_deprecated_level
+            Autoproj.warn_deprecated_level = -1
+            capture_subprocess_io do
+                yield
+            end
+        ensure
+            Autoproj.warn_deprecated_level = level
+        end
+
         def find_bundled_gem_path(bundler, gem_name, gemfile)
             out_r, out_w = IO.pipe
             result = Bundler.clean_system(
@@ -217,6 +246,130 @@ def workspace_env(varname)
             stdout.chomp
         end
 
+        attr_reader :ws_os_package_resolver
+
+        def ws_define_package_manager(name, strict: false, call_while_empty: false)
+            manager = Class.new(PackageManagers::Manager)
+            manager.class_eval do
+                define_method(:strict?) { strict }
+                define_method(:call_while_empty?) { call_while_empty }
+            end
+            manager = flexmock(manager),
+            ws_package_managers[name] = manager
+        end
+
+        def ws_create_os_package_resolver
+            @ws_os_package_resolver = OSPackageResolver.new(
+                operating_system: [['test_os_family'], ['test_os_version']],
+                package_managers: ws_package_managers.keys,
+                os_package_manager: 'os')
+        end
+
+        def ws_create
+            dir = make_tmpdir
+            require 'autoproj/ops/main_config_switcher'
+            FileUtils.cp_r Ops::MainConfigSwitcher::MAIN_CONFIGURATION_TEMPLATE, File.join(dir, 'autoproj')
+            FileUtils.mkdir_p File.join(dir, '.autoproj')
+
+            ws_create_os_package_resolver
+            @ws = Workspace.new(
+                dir, os_package_resolver: ws_os_package_resolver,
+                     package_managers: ws_package_managers)
+            ws.config.set 'osdeps_mode', 'all'
+            ws.config.set 'gems_install_path', File.join(dir, 'gems')
+            ws.config.save
+            ws.prefix_dir = make_tmpdir
+            ws
+        end
+
+        def ws_clear_layout
+            ws.manifest.clear_layout
+        end
+
+        def ws_define_package_set(name, vcs = VCSDefinition.from_raw(type: 'none'), **options)
+            package_set = PackageSet.new(ws, vcs, name: name, **options)
+            ws.manifest.register_package_set(package_set)
+            package_set
+        end
+
+        def ws_add_package_set_to_layout(name, vcs = VCSDefinition.from_raw(type: 'none'), **options)
+            package_set = ws_define_package_set(name, vcs, **options)
+            ws.manifest.add_package_set_to_layout(package_set)
+            package_set
+        end
+
+        def ws_define_osdep_entries(entries)
+            ws_os_package_resolver.add_entries(entries)
+        end
+
+        def ws_add_osdep_entries_to_layout(entries)
+            ws_os_package_resolver.add_entries(entries)
+            entries.each_key do |pkg_name|
+                ws.manifest.add_package_to_layout(pkg_name)
+            end
+        end
+
+        def ws_define_package(package_type, package_name, package_set: ws.manifest.main_package_set, create: true)
+            package = Autobuild.send(package_type, package_name)
+            package.srcdir = File.join(ws.root_dir, package_name.to_s)
+            if create
+                FileUtils.mkdir_p package.srcdir
+            end
+            autoproj_package = ws.register_package(package, nil, package_set)
+            yield(package) if block_given?
+            autoproj_package
+        end
+
+        def ws_define_package_vcs(package, vcs_spec)
+            package.package_set.add_version_control_entry(package.name, vcs_spec)
+        end
+
+        def ws_define_package_overrides(package, package_set, vcs_spec)
+            package_set.add_overrides_entry(package.name, vcs_spec)
+        end
+
+        def ws_add_package_to_layout(package_type, package_name, package_set: ws.manifest.main_package_set, &block)
+            pkg = ws_define_package(package_type, package_name, package_set: package_set, &block)
+            ws.manifest.add_package_to_layout(pkg)
+            pkg
+        end
+
+        def ws_set_version_control_entry(package, entry)
+            package.package_set.add_version_control_entry(package.name, entry)
+        end
+
+        def ws_set_overrides_entry(package, package_set, entry)
+            package_set.add_overrides_entry(package.name, entry)
+        end
+
+        def ws_setup_package_dirs(package, create_srcdir: true)
+            package.autobuild.srcdir = srcdir = File.join(ws.root_dir, package.name)
+            if create_srcdir
+                FileUtils.mkdir_p srcdir
+            elsif File.directory?(srcdir)
+                FileUtils.rm_rf srcdir
+            end
+            package.autobuild.builddir = builddir = File.join(ws.root_dir, 'build', package.name)
+            package.autobuild.prefix = prefix = File.join(ws.root_dir, 'prefix', package.name)
+            return srcdir, builddir, prefix
+        end
+
+        def ws_create_git_package_set(name, source_data = Hash.new)
+            dir = make_tmpdir
+            if !system('git', 'init', chdir: dir, out: :close)
+                raise "failed to run git init"
+            end
+            File.open(File.join(dir, 'source.yml'), 'w') do |io|
+                YAML.dump(Hash['name' => name].merge(source_data), io)
+            end
+            if !system('git', 'add', 'source.yml', chdir: dir, out: :close)
+                raise "failed to add the source.yml"
+            end
+            if !system('git', 'commit', '-m', 'add source.yml', chdir: dir, out: :close)
+                raise "failed to commit the source.yml"
+            end
+            dir
+        end
     end
 end
 

data/lib/autoproj/variable_expansion.rb

@@ -26,40 +26,15 @@ def self.flatten_recursive_hash(hash, prefix = "")
         result
     end
 
-    # Expand build options in +value+.
-    #
-    # The method will expand in +value+ patterns of the form $NAME, replacing
-    # them with the corresponding build option.
-    def self.expand_environment(value)
-        return value if !contains_expansion?(value)
-
-        # Perform constant expansion on the defined environment variables,
-        # including the option set
-        options = flatten_recursive_hash(config.validated_values)
-
-        loop do
-            new_value = single_expansion(value, options)
-            if new_value == value
-                break
-            else
-                value = new_value
-            end
-        end
-        value
-    end
-
     # Does a non-recursive expansion in +data+ of configuration variables
     # ($VAR_NAME) listed in +definitions+
     #
     # If the values listed in +definitions+ also contain configuration
     # variables, they do not get expanded
-    def self.single_expansion(data, definitions, options = Hash.new)
-        options = Kernel.validate_options options, config: Autoproj.config
-
+    def self.single_expansion(data, definitions)
         if !data.respond_to?(:to_str)
             return data
         end
-        definitions = { 'HOME' => ENV['HOME'] }.merge(definitions)
 
         data = data.gsub(/(.|^)\$(\w+)/) do |constant_name|
             prefix = constant_name[0, 1]
@@ -72,11 +47,10 @@ def self.single_expansion(data, definitions, options = Hash.new)
                 constant_name = constant_name[2..-1]
             end
 
-            if !(value = definitions[constant_name])
-                if !(value = options[:config].get(constant_name))
-                    if !block_given? || !(value = yield(constant_name))
-                        raise ArgumentError, "cannot find a definition for $#{constant_name}"
-                    end
+            value = definitions[constant_name]
+            if value.nil?
+                if !block_given? || !(value = yield(constant_name))
+                    raise ArgumentError, "cannot find a definition for $#{constant_name}"
                 end
             end
             "#{prefix}#{value}"
@@ -109,8 +83,9 @@ def self.expand(value, definitions = Hash.new)
     def self.contains_expansion?(string); string =~ /\$/ end
 
     def self.resolve_one_constant(name, value, result, definitions)
-        result[name] = single_expansion(value, result) do |missing_name|
-            result[missing_name] = resolve_one_constant(missing_name, definitions.delete(missing_name), result, definitions)
+        result[name] ||= single_expansion(value, result) do |missing_name|
+            result[missing_name] =
+                resolve_one_constant(missing_name, definitions[missing_name], result, definitions)
         end
     end
 
@@ -118,17 +93,15 @@ def self.resolve_one_constant(name, value, result, definitions)
     #
     # 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']
+    def self.resolve_constant_definitions(constants, definitions = Hash.new)
+        definitions = definitions.merge(constants)
         
-        result = Hash.new
-        while !constants.empty?
-            name  = constants.keys.first
-            value = constants.delete(name)
-            resolve_one_constant(name, value, result, constants)
+        all_resolutions = Hash.new
+        resolution_cache = Hash.new
+        constants.each do |key, value|
+            all_resolutions[key] = resolve_one_constant(key, value, resolution_cache, definitions)
         end
-        result
+        all_resolutions
     end
 end
 

data/lib/autoproj/vcs_definition.rb

@@ -22,36 +22,39 @@ class VCSDefinition
         # i.e. the list of VCSDefinition objects that led to this one by means
         # of calls to {#update}
         #
-        # @return [Array<VCSDefinition>]
+        # @return [Array<HistoryEntry>]
         attr_reader :history
 
         # The original spec in hash form
         #
-        # Set if this VCSDefinition object has been created using
-        # VCSDefinition.from_raw
-        #
-        # @return [nil,Hash]
+        # @return [Array<RawEntry>]
         attr_reader :raw
 
-        def initialize(type, url, vcs_options, options = Hash.new)
-            if raw && !raw.respond_to?(:to_ary)
+        HistoryEntry  = Struct.new :package_set, :vcs
+        RawEntry      = Struct.new :package_set, :file, :vcs
+
+        def initialize(type, url, vcs_options, from: nil, raw: Array.new, history: Array.new)
+            if !raw.respond_to?(:to_ary)
                 raise ArgumentError, "wrong format for the raw field (#{raw.inspect})"
             end
-            if !options.kind_of?(Hash)
-                options = Hash[raw: options]
-            end
-            if vcs_options[:raw]
-                raise
-            end
-            options = validate_options options, from: nil, raw: nil, history: nil
 
             @type, @url, @options = type, url, vcs_options
             if type != "none" && type != "local" && !Autobuild.respond_to?(type)
                 raise ConfigError.new, "version control #{type} is unknown to autoproj"
             end
 
-            @history = (options[:history] || Array.new) + [[options[:from], self]]
-            @raw = options[:raw] || [[options[:from], to_hash]]
+            @history = history + [HistoryEntry.new(from, self)]
+            @raw     = raw
+        end
+
+        # Create a null VCS object
+        def self.none
+            from_raw(type: 'none')
+        end
+
+        # Whether there is actually a version control definition
+        def none?
+            @type == 'none'
         end
 
         # Whether this points to a local directory
@@ -70,21 +73,16 @@ def to_hash
         # the updated definition
         #
         # @return [VCSDefinition]
-        def update(spec, options = Hash.new)
-            if !options.kind_of?(Hash)
-                options = Hash[raw: options]
-            end
-            from, options = filter_options options, from: nil, raw: nil
-            from = from[:from]
-            new = self.class.vcs_definition_to_hash(spec)
-            new_raw  = options[:raw] || [[from, spec]]
+        def update(spec, from: nil, raw: Array.new)
+            new = self.class.normalize_vcs_hash(spec)
+            new_raw = Array.new
             new_history = Array.new
 
             # If the type changed, we replace the old definition by the new one
             # completely. Otherwise, we append it to the current one
             if !new.has_key?(:type) || (type == new[:type])
                 new = to_hash.merge(new)
-                new_raw = self.raw + new_raw
+                new_raw = self.raw + raw
                 new_history = self.history
             end
             self.class.from_raw(new, from: from, history: new_history, raw: new_raw)
@@ -95,9 +93,9 @@ def update(spec, options = Hash.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
-        # {.vcs_definition_to_hash}. +new+ can be in "raw" form.
+        # {.normalize_vcs_hash}. +new+ can be in "raw" form.
         def self.update_raw_vcs_spec(old, new)
-            new = vcs_definition_to_hash(new)
+            new = normalize_vcs_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
@@ -115,7 +113,7 @@ def self.update_raw_vcs_spec(old, new)
         #
         #   - package_name
         #     branch: value
-        def self.vcs_definition_to_hash(spec)
+        def self.normalize_vcs_hash(spec, base_dir: nil)
             plain = Array.new
             filtered_spec = Hash.new
 
@@ -141,24 +139,26 @@ def self.vcs_definition_to_hash(spec)
                 # 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(':'))
+                    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 =
                         if Pathname.new(short_url).absolute?
                             File.expand_path(short_url)
+                        elsif base_dir
+                            File.expand_path(short_url, base_dir)
                         else
-                            File.expand_path(File.join(Autoproj.config_dir, short_url))
+                            raise ArgumentError, "VCS path '#{short_url}' is relative and no base_dir was given"
                         end
                     if !File.directory?(source_dir)
-                        raise ConfigError.new, "'#{spec.inspect}' is neither a remote source specification, nor an existing local directory"
+                        raise ArgumentError, "'#{short_url}' is neither a remote source specification, nor an existing local directory"
                     end
-                    spec.merge!(:type => 'local', :url => source_dir)
+                    spec.merge!(type: 'local', url: source_dir)
                 end
             end
 
-            spec, vcs_options = Kernel.filter_options spec, :type => nil, :url => nil
+            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
@@ -176,6 +176,13 @@ def self.vcs_definition_to_hash(spec)
             spec
         end
 
+        # @api private
+        #
+        # Converts a raw spec (a hash, really) into a nicely formatted string
+        def self.raw_spec_to_s(spec)
+            "{ #{spec.sort_by(&:first).map { |k, v| "#{k}: #{v}" }.join(", ")} }"
+        end
+
         # Converts a 'raw' VCS representation to a normalized hash.
         #
         # The raw definition can have three forms:
@@ -186,29 +193,30 @@ def self.vcs_definition_to_hash(spec)
         # @return [VCSDefinition]
         # @raise ArgumentError if the raw specification does not match an
         #   expected format
-        def self.from_raw(spec, options = Hash.new)
-            if !options.kind_of?(Hash)
-                options = Hash[raw: options]
-            end
-            options = validate_options options, from: nil, raw: nil, history: nil
-            from = options[:from]
-            history = options[:history] || Array.new
-            raw = options[:raw] || [[from, 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"
+        def self.from_raw(spec, from: nil, raw: Array.new, history: Array.new)
+            normalized_spec = normalize_vcs_hash(spec)
+            if !(type = normalized_spec.delete(:type))
+                raise ArgumentError, "the source specification #{raw_spec_to_s(spec)} normalizes into #{raw_spec_to_s(normalized_spec)}, which does not have a VCS type"
+            elsif !(url  = normalized_spec.delete(:url))
+                if type != 'none'
+                    raise ArgumentError, "the source specification #{raw_spec_to_s(spec)} normalizes into #{raw_spec_to_s(normalized_spec)}, which does not have a URL. Only VCS of type 'none' do not require one"
+                end
             end
 
-            spec, vcs_options = Kernel.filter_options spec, :type => nil, :url => nil
-            return VCSDefinition.new(spec[:type], spec[:url], vcs_options, from: from, history: history, raw: raw)
+            VCSDefinition.new(type, url, normalized_spec, from: from, history: history, raw: raw)
         end
 
         def ==(other_vcs)
             return false if !other_vcs.kind_of?(VCSDefinition)
             if local?
-                other_vcs.local? && url == other.url
-            elsif !other_vcs.local?
+                other_vcs.local? && url == other_vcs.url
+            elsif other_vcs.local?
+                false
+            elsif none?
+                other_vcs.none?
+            elsif other_vcs.none?
+                false
+            else
                 this_importer = create_autobuild_importer
                 other_importer = other_vcs.create_autobuild_importer
                 this_importer.source_id == other_importer.source_id
@@ -223,14 +231,11 @@ def eql?(other_vcs)
             to_hash == other_vcs.to_hash
         end
 
-        def self.to_absolute_url(url, root_dir = nil)
-            # NOTE: we MUST use nil as default argument of root_dir as we don't
-            # want to call Autoproj.root_dir unless completely necessary
-            # (to_absolute_url might be called on installations that are being
-            # bootstrapped, and as such don't have a root dir yet).
-            url = Autoproj.single_expansion(url, 'HOME' => ENV['HOME'])
-            if url && url !~ /^(\w+:\/)?\/|^[:\w]+\@|^(\w+\@)?[\w\.-]+:/
-                url = File.expand_path(url, root_dir || Autoproj.root_dir)
+        ABSOLUTE_PATH_OR_URI = /^([\w+]+:\/)?\/|^[:\w]+\@|^(\w+\@)?[\w\.-]+:/
+
+        def self.to_absolute_url(url, root_dir)
+            if url && url !~ ABSOLUTE_PATH_OR_URI
+                url = File.expand_path(url, root_dir)
             end
             url
         end
@@ -240,6 +245,15 @@ def needs_import?
             type != 'none' && type != 'local'
         end
 
+        def overrides_key
+            return if none?
+            if local?
+                "local:#{url}"
+            else
+                create_autobuild_importer.repository_id
+            end
+        end
+
         # Returns a properly configured instance of a subclass of
         # Autobuild::Importer that match this VCS definition
         #
@@ -247,13 +261,13 @@ def needs_import?
         def create_autobuild_importer
             return if !needs_import?
 
-            url = VCSDefinition.to_absolute_url(self.url)
             importer = Autobuild.send(type, url, options)
             if importer.respond_to?(:declare_alternate_repository)
-                history.each do |from, vcs|
-                    next if !from || from.main?
-                    url = VCSDefinition.to_absolute_url(vcs.url)
-                    importer.declare_alternate_repository(from.name, url, vcs.options)
+                history.each do |entry|
+                    package_set = entry.package_set
+                    vcs         = entry.vcs
+                    next if !package_set || package_set.main?
+                    importer.declare_alternate_repository(package_set.name, vcs.url, vcs.options)
                 end
             end
             importer
@@ -295,30 +309,33 @@ def self.call_source_handler(vcs, url, options)
         end
     end
 
-    # call-seq:
-    #   Autoproj.add_source_handler name do |url, options|
-    #     # build a hash that represent source configuration
-    #     # and return it
-    #   end
-    #
     # Add a custom source handler named +name+
     #
     # Custom source handlers are shortcuts that can be used to represent VCS
-    # information. For instance, the gitorious_server_configuration method
-    # defines a source handler that allows to easily add new gitorious packages:
-    #
-    #   gitorious_server_configuration 'GITORIOUS', 'gitorious.org'
+    # information. For instance, the {Autoproj.git_server_configuration} helper defines a
+    # source handler that allows to easily add new github packages:
     #
-    # defines the "gitorious" source handler, which allows people to write
+    #   Autoproj.git_server_configuration('GITHUB', 'github.com',
+    #      http_url: 'https://github.com',
+    #      default: 'http,ssh')
     #
+    # Defines a 'github' custom handler that expands into the full VCS
+    # configuration to access github
     #
     #   version_control:
-    #       - tools/orocos.rb
-    #         gitorious: rock-toolchain/orocos-rb
+    #       - tools/orocos.rb:
+    #         github: rock-core/base-types
     #         branch: test
-    #
     # 
+    # @yieldparam [String] url the url given to the handler
+    # @yieldparam [Hash] the rest of the VCS hash
+    # @return [Hash] a VCS hash with the information expanded
     def self.add_source_handler(name, &handler)
         @custom_source_handlers[name.to_s] = lambda(&handler)
     end
+
+    # Deregister a source handler defined with {.add_source_handler}
+    def self.remove_source_handler(name)
+        @custom_source_handlers.delete(name)
+    end
 end