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):
     if not lib.which('git'):
         self.logger.warn("git is not installed! Please install git to install this feature.")
         return
     target_directory = self.directory.install_directory(self.feature_name)
     source_branch = self.source.get('branch', 'master')
     target_branch = self.target.get('branch', 'master')
     if self.target.get('url') != self.source.get('url') or \
        not os.path.exists(target_directory):
         if os.path.exists(target_directory):
             self.logger.debug("Old git repository Found. Deleting...")
             self.directory.remove_feature(self.feature_name)
         self.__clone_repo(self.target.get('url'),
                           target_directory,
                           branch=self.target.get('branch', 'master'))
     elif source_branch != target_branch:
         self.__checkout_branch(target_directory, target_branch)
     else:
         if not os.path.exists(target_directory):
             self.logger.debug("No repository cloned. Re-cloning...")
             self.__clone_repo(self.target.get('url'),
                               target_directory,
                               branch=target_branch)
         os.chdir(target_directory)
         error, output = lib.call("git pull origin %s" % target_branch,
                                  output_log_level=logging.DEBUG)
         if error:
             self.logger.info(output)
             raise GitException("An error occurred when pulling!")
     FormulaBase.update(self)

 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 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 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'))
     self.system.isDebianBased = Mock(return_value=True)
     assert fb.should_run()
     self.system.isDebianBased = Mock(return_value=False)
     assert not fb.should_run()

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

 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 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 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):
     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)
             self.__add_paths(self.target)
     return FormulaBase.update(self)

 def update(self):
     if self.source.get("url") != self.target.get("url"):
         if os.path.exists(self.directory.install_directory(self.feature_name)):
             try:
                 self.directory.remove_feature(self.feature_name)
             except DirectoryException:
                 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")))
             except DirectoryException:
                 pass
     if self.target.has("executable"):
         symlink = self.target.get("symlink", self.target.get("executable"))
         if not os.path.exists(symlink):
             self.__symlink_executable(self.target.get("executable"), symlink)
     FormulaBase.update(self)

 def test_osx_only(self):
     """ Test a feature that should only occur on osx """
     fb = FormulaBase(self.environment, 'osx',
                      target=self.environment.target.get_feature_config('osx'))
     fb2 = FormulaBase(self.environment, 'osx2',
                       target=self.environment.target.get_feature_config('osx2'))
     self.system.isOSX = Mock(return_value=True)
     assert fb.should_run()
     assert fb2.should_run()
     self.system.isOSX = Mock(return_value=False)
     assert not fb.should_run()
     assert not fb2.should_run()

 def remove(self, feature_name, config):
     if self.source.is_affirmative('remove_file_on_delete', False):
         os.path.unlink(
             os.path.expanduser(self.source.get('target')))
     FormulaBase.remove(feature_name, config)

 def update(self):
     if self.target.has('on_update') and self.target.is_affirmative('on_update'):
         self.__install_file(self.target)
     FormulaBase.update(self)

 def install(self):
     self.__install_file(self.target)
     FormulaBase.install(self)

 def update(self):
     for c in (c for c in self.target.keys() if c not in self.ignored_keys):
         self.directory.add_to_env('export %s=%s' % (c.upper(), self.target.get(c)))
     FormulaBase.update(self)

 def install(self):
     self.__run_command('install', 'target')
     FormulaBase.install(self)

 def update(self):
     self.__run_command('update', 'target')
     FormulaBase.update(self)

 def deactivate(self):
     self.__run_command('deactivate', 'source')
     FormulaBase.deactivate(self)