def validate(self):
     FormulaBase.validate(self)
     config = self.target or self.source
     version = config.get('version', 'r13.2')
     if version not in package_dict:
         raise PerforceFormulaException("Version %s in not supported by perforce formula!\n" % version +
                                        "Supported versions are: %s" % ", ".join(package_dict.keys()))

    def update(self):
        acted = False
        if not os.path.exists(self._get_destination()):
            self.install()
            return True

        if self.source.get('url') != self.target.get('url'):
            acted = True
            if os.path.exists(self.directory.install_directory(self.feature_name)):
                try:
                    self.directory.remove_feature(self.feature_name)
                except DirectoryException:
                    self.logger.exception()
                    self.logger.error("Unable to remove old directory!")
            self.__install(self.target)
        if self.source.has('executable'):
            symlink = self.source.get('symlink', self.source.get('executable'))
            if os.path.exists(symlink) and os.path.islink(symlink):
                try:
                    self.directory.remove_from_bin(
                        self.source('symlink', self.source.get('executable')))
                    acted = True
                except DirectoryException:
                    pass
        if self.target.has('executable'):
            symlink = self.target.get('symlink', self.target.get('executable'))
            if not os.path.exists(symlink):
                acted = True
                self.__symlink_executable(self.target.get('executable'),
                                          symlink)
        FormulaBase.update(self)
        return acted

 def validate(self):
     if self.target:
         if (self.target.has('username') and not self.target.has('password') or
            self.target.has('password') and not self.target.has('username')):
             self.logger.warn("Username and password are " +
                              "both required to authenticate to a source!")
     FormulaBase.validate(self)

 def update(self):
     acted = False
     if self.target.has('on_update') and self.target.is_affirmative('on_update'):
         self.__install_file(self.target)
         acted = True
     FormulaBase.update(self)
     return acted

 def install(self):
     self.__install(self.target)
     if self.target.has('executable'):
         symlink_target = self.target.get('symlink',
                                          self.target.get('executable'))
         self.__symlink_executable(self.target.get('executable'),
                                   symlink_target)
     FormulaBase.install(self)

 def test_debianbased_only(self):
     """ Test a feature that should only occur on debian-based distributions """
     fb = FormulaBase(self.environment, "debian", target=self.environment.target.get_feature_config("debian"))
     with patch("sprinter.lib.system.is_debian") as is_debian:
         is_debian.return_value = True
         assert fb.should_run()
         is_debian.return_value = False
         assert not fb.should_run()

 def install(self):
     if not lib.which('git'):
         self.logger.warn("git is not installed! Please install git to install this feature.")
         return
     self.__clone_repo(self.target.get('url'),
                       self.directory.install_directory(self.feature_name),
                       branch=self.target.get('branch', 'master'))
     FormulaBase.install(self)

 def update(self):
     acted = False
     if self.source.get('version', 'r13.2') != self.target.get('version', 'r13.2'):
         os.unlink(os.path.join(self.directory.install_directory(self.feature_name), 'p4'))
         self.__install_perforce(self.target)
         acted = True
     self.__add_p4_env(self.target)
     FormulaBase.update(self)
     return acted

 def test_prompt_value_default(self):
     """ _prompt_value default should be overwritten by the source if it exists """
     fb = FormulaBase(self.environment, 'prompt_value',
                      source=self.environment.source.get_feature_config('prompt_value_source'),
                      target=self.environment.target.get_feature_config('prompt_value_source'))
     with patch('sprinter.lib.prompt') as prompt:
         prompt.return_value = "foo"
         fb._prompt_value('source_value', 'this value exists')
         prompt.assert_called_once_with('this value exists', default="old")

 def update(self):
     acted = False
     if (self.source.get('egg', '') != self.target.get('egg', '') or
         self.source.get('eggs', '') != self.target.get('eggs', '') or
         (self.target.has('redownload') and self.target.is_affirmative('redownload'))):
             self.__install_eggs(self.target)
             acted = True
     self.__add_paths(self.target)
     FormulaBase.update(self)
     return acted

 def test_prompt_value(self):
     """ _prompt_value should prompt a value if it does not exist in the target """
     fb = FormulaBase(self.environment, 'prompt_value',
                      target=self.environment.target.get_feature_config('prompt_value'))
     with patch('sprinter.lib.prompt') as prompt:
         prompt.return_value = "foo"
         fb._prompt_value('existing_value', 'this value exists')
         assert fb.target.get('existing_value') == "here"
         fb._prompt_value('non_existing_value', "this value doesn't exists")
         assert fb.target.get('non_existing_value') == "foo"

 def remove(self):
     if self.source.has('executable'):
         symlink = self.source.get('symlink', self.source.get('executable'))
         if os.path.exists(symlink) and os.path.islink(symlink):
             try:
                 self.directory.remove_from_bin(
                     self.source('symlink', self.source.get('executable')))
             except DirectoryException:
                 pass
     FormulaBase.remove(self)

 def test_resolve_dont_carry_over_options(self):
     """ resolve should resolve non-carry over options """
     fb = FormulaBase(
         self.environment,
         "prompt_value",
         source=self.environment.source.get_feature_config("resolve"),
         target=self.environment.target.get_feature_config("resolve"),
     )
     fb.resolve()
     assert not fb.target.has("systems")
     assert not fb.target.has("depends")

 def update(self):
     self.__get_package_manager()
     install_package = False
     if self.package_manager and self.target.has(self.package_manager):
         if not self.source.has(self.package_manager):
             install_package = True
         if self.source.get(self.package_manager) != self.target.get(self.package_manager):
             install_package = True
     if install_package:
         self.__install_package(self.target)
     FormulaBase.update(self)

 def validate(self):
     FormulaBase.validate(self)
     if self.target:
         versions = self.target.get('version').split('.')
         if len(versions) != 3:
             self._log_error("Version string %s is invalid! please format it as : X.X.X")
         for v in versions:
             try:
                 int(v)
             except ValueError:
                 self._log_error("Versions must all be integers! %s is not one" % v)

 def test_prompt_value_default(self):
     """ _prompt_value default should be overwritten by the source if it exists """
     fb = FormulaBase(
         self.environment,
         "prompt_value",
         source=self.environment.source.get_feature_config("prompt_value_source"),
         target=self.environment.target.get_feature_config("prompt_value_source"),
     )
     with patch("sprinter.lib.prompt") as prompt:
         prompt.return_value = "foo"
         fb._prompt_value("source_value", "this value exists")
         prompt.assert_called_once_with("this value exists", default="old")

 def install(self):
     config = self.target
     self.p4environ = dict(list(os.environ.items()) + [('P4USER', config.get('username')),
                                                       ('P4PASSWD', config.get('password')),
                                                       ('P4CLIENT', config.get('client'))])
     installed = self.__install_perforce(config)
     if not os.path.exists(os.path.expanduser(config.get('root_path'))):
         os.makedirs(os.path.expanduser(config['root_path']))
     if config.is_affirmative('write_p4settings'):
         self.__write_p4settings(config)
     if config.is_affirmative('overwrite_client') and installed:
         self.__configure_client(config)
     self.__add_p4_env(config)
     FormulaBase.install(self)

 def update(self):
     fresh = False
     if self.source.get('version') != self.target.get('version'):
         self.directory.remove_feature(self.feature_name)
         fresh = True
     if not os.path.exists(
             self.directory.install_directory(self.feature_name)
     ):
         fresh = True
     if fresh:
         self._install_node()
     self._link_executables()
     self._install_packages(fresh=fresh)
     FormulaBase.update(self)

    def update(self):
        source_opts = self.__get_options(self.source)
        target_opts = self.__get_options(self.target)

        # compare old and new link source and link target
        if (source_opts['source'] != target_opts['source'] or
            source_opts['target'] != target_opts['target']):
            self.__remove_symlink(**source_opts)
            self.__create_symlink(**target_opts)

        return FormulaBase.update(self)

 def validate(self):
     if self.target:
         target_opts = self.__get_options(self.target)
         for k in self._required_options:
             if k not in target_opts:
                 error_message = "Required option {option} not present in feature {feature}!".format(
                     option=k, feature=self.feature_name)
                 if self.target.is_affirmative('fail_on_error', False):
                     self._log_error(error_message)
                 else:
                     self.logger.error(error_message)
     return FormulaBase.validate(self)