public static function createDirectory($original_path, $type, Environment $environment)
 {
     $paths = pathinfo($original_path);
     $dirname = realpath($paths['dirname']);
     if (!$dirname || !is_dir($dirname) || !is_readable($dirname)) {
         if (@mkdir($original_path, 0777, true) === true) {
             $realpath = $original_path;
         } else {
             return $environment->set_error(ucfirst($type) . " parent path '{$paths['dirname']}' does not exist.  Please correct the path or create the directory.");
         }
     }
     $path = $dirname . '/' . $paths['basename'];
     $realpath = realpath($path);
     if ($realpath === false || !file_exists($realpath)) {
         if (@mkdir($path, 0777, true) === true) {
             $realpath = $path;
         } else {
             return $environment->set_error("Unable to create directory '{$path}'.  Please make the directory manually or check the permissions of the parent directory.");
         }
     } elseif (!is_readable($realpath) || !is_writable($realpath)) {
         @chmod($realpath, 0777);
     }
     if (substr($realpath, -1) != '/') {
         $realpath .= '/';
     }
     if (is_dir($realpath) && is_readable($realpath) && is_writable($realpath)) {
         return $realpath;
     } else {
         return $environment->set_error("Path to directory for {$type} is not valid.  Please correct the path or create the directory and check that is readable and writable.");
     }
 }

 public function setDefaultEnv($environment)
 {
     $env = new Environment();
     if (is_object($env->add($environment))) {
         $this->currentEnviroment = $environment;
     }
 }

 /**
  * Change the user's environment-level role.
  *
  * @param Environment $environment
  * @param string      $newRole The new role ('admin', 'contributor',
  *                             or 'viewer').
  */
 public function changeEnvironmentRole(Environment $environment, $newRole)
 {
     if (!in_array($newRole, ['admin', 'contributor', 'viewer'])) {
         throw new \InvalidArgumentException("Invalid role: {$newRole}");
     }
     $this->sendRequest($environment->getUri() . '/access/' . $this->id, 'patch', ['json' => ['role' => $newRole]]);
 }

 public function testGet()
 {
     $get = array('n' => 'v');
     $env = new Environment($get, array(), array());
     $this->assertEquals('v', $env->get('n'));
     $this->assertNull($env->get('not-existed-param'));
 }

 /**
  * Proxy method that handles return of assets instead of instant output.
  *
  * @param  Environment $env
  * @param  string $method
  * @param  string|null $options Assets CollectionName
  * @return string
  */
 protected function getAssetsOutput(Environment $env, $method, $options = null)
 {
     $env->getDi()->get('assets')->useImplicitOutput(false);
     $result = $env->getDi()->get('assets')->{$method}($options);
     $env->getDi()->get('assets')->useImplicitOutput(true);
     return $result;
 }

 function setEnvironment(Environment $env)
 {
     $this->environment = $env;
     $env->setLoader($this);
     Controller::setEnvironment($env);
     return $this;
 }

 /**
  * Test that the parser gets its values from the $_SERVER and $_ENV environment variables
  */
 public function testUsesEnvironmentVariables()
 {
     $_SERVER['foo'] = 'bar';
     $_ENV['test'] = 'example';
     $configuration = $this->parser->parse();
     $this->assertArrayHasKey('foo', $configuration);
     $this->assertArrayHasKey('test', $configuration);
 }

 public static function saveCachedEnvironmentObject()
 {
     if (!file_exists(DIR_FILES_CACHE . '/' . FILENAME_ENVIRONMENT_CACHE)) {
         $env = new Environment();
         $env->getOverrides();
         @file_put_contents(DIR_FILES_CACHE . '/' . FILENAME_ENVIRONMENT_CACHE, serialize($env));
     }
 }

 static function init($ApiKey, Environment $env)
 {
     if ($env->getBaseUrl() != Environment::PROD and $env->getBaseUrl() != Environment::TEST and $env->getBaseUrl() != Environment::DEV) {
         throw new \InvalidArgumentException('$env must be Apruve\\Environment::PROD or Apruve\\Environment::TEST to be valid.');
     }
     ClientStorage::setEnvironment($env);
     ClientStorage::setApiKey($ApiKey);
     return new Client();
 }

 public function register(Environment $environment)
 {
     $env = $environment->getEnv();
     foreach ($env['packages'] as $k => $e) {
         if ($k !== "Syph") {
             $this->app_container_config[$k] = array("app_path_conf" => $e . DS . "Config" . DS . "config.php");
         }
     }
 }

 /**
  * Create a normalized tree of UploadedFile instances from the Environment.
  *
  * @param Environment $env The environment
  *
  * @return array|null A normalized tree of UploadedFile instances or null if none are provided.
  */
 public static function createFromEnvironment(Environment $env)
 {
     if (is_array($env['slim.files']) && $env->has('slim.files')) {
         return $env['slim.files'];
     } elseif (isset($_FILES)) {
         return static::parseUploadedFiles($_FILES);
     }
     return [];
 }

 /**
  * Tests if module was activated.
  *
  * @dataProvider providerModuleActivation
  *
  * @param array  $aInstallModules
  * @param string $sModule
  * @param array  $aResultToAsserts
  */
 public function testModuleActivation($aInstallModules, $sModule, $aResultToAsserts)
 {
     $oEnvironment = new Environment();
     $oEnvironment->prepare($aInstallModules);
     $oModule = oxNew('oxModule');
     $oModule->load($sModule);
     $this->deactivateModule($oModule);
     $this->activateModule($oModule);
     $this->runAsserts($aResultToAsserts);
 }

 /**
  * Checks the site's mode and suggests SFTP if it is not set.
  *
  * @param Environment $environment Environment object to check mode of
  * @return void
  */
 protected function checkConnectionMode($environment)
 {
     if ($environment->getConnectionMode() != 'sftp') {
         $message = 'Note: This environment is in read-only Git mode. If you ';
         $message .= 'want to make changes to the codebase of this site ';
         $message .= '(e.g. updating modules or plugins), you will need to ';
         $message .= 'toggle into read/write SFTP mode first.';
         $this->log()->warning($message);
     }
 }

 public function testModulesWithoutMetadataShouldBeAddToCleanupAllModulesWithMetadata()
 {
     // modules to be activated during test preparation
     $aInstallModules = array('extending_1_class');
     $oEnvironment = new Environment();
     $oEnvironment->prepare($aInstallModules);
     $oModuleList = oxNew('oxModuleList');
     $aGarbage = $oModuleList->getDeletedExtensions();
     $this->assertSame(array(), $aGarbage);
 }

 /**
  * {@inheritdoc}
  *
  * @throws \Icicle\File\Exception\FileException
  * @throws \Icicle\Exception\InvalidArgumentError
  */
 public function run(Environment $environment)
 {
     if ('f' === $this->operation[0]) {
         if ('fopen' === $this->operation) {
             $file = new File($this->args[0], $this->args[1]);
             $id = $file->getId();
             $environment->set($this->makeId($id), $file);
             return [$id, $file->stat()['size'], $file->inAppendMode()];
         }
         if (null === $this->id) {
             throw new FileException('No file ID provided.');
         }
         if (!$environment->exists($this->id)) {
             throw new FileException('No file handle with the given ID has been opened on the worker.');
         }
         if (!($file = $environment->get($this->id)) instanceof File) {
             throw new FileException('File storage found in inconsistent state.');
         }
         switch ($this->operation) {
             case 'fread':
             case 'fwrite':
             case 'fseek':
             case 'fstat':
             case 'ftruncate':
                 return [$file, substr($this->operation, 1)](...$this->args);
             case 'fclose':
                 $environment->delete($this->id);
                 return true;
             default:
                 throw new InvalidArgumentError('Invalid operation.');
         }
     }
     switch ($this->operation) {
         case 'stat':
         case 'unlink':
         case 'rename':
         case 'copy':
         case 'link':
         case 'symlink':
         case 'readlink':
         case 'isfile':
         case 'isdir':
         case 'mkdir':
         case 'lsdir':
         case 'rmdir':
         case 'chmod':
         case 'chown':
         case 'chgrp':
             return [$this, $this->operation](...$this->args);
         default:
             throw new InvalidArgumentError('Invalid operation.');
     }
 }

 static function compileTwigMoreHaml($hamlstr, $options, $moreOptions = null)
 {
     static $env;
     if (!is_null($options)) {
         $env = new Environment('twig_more', $options);
     }
     if ($env) {
         return $env->compileString($hamlstr, $moreOptions);
     } else {
         throw new Exception\MoreException('plz supply 2nd arg when calling this func first time');
     }
 }

 /**
  * Test check shop environment after activation of module with similar name as deactivated module
  *
  * @dataProvider providerModuleReactivation
  *
  * @param array  $installModules
  * @param string $sReactivateModule
  * @param array  $aResultToAssert
  */
 public function testModuleActivateWithSimilarName($installModules, $sReactivateModule, $aResultToAssert)
 {
     $environment = new Environment();
     $environment->prepare($installModules);
     foreach ($installModules as $sModule) {
         $oModule = oxNew('oxModule');
         $this->deactivateModule($oModule, $sModule);
     }
     $oModule = oxNew('oxModule');
     $this->activateModule($oModule, $sReactivateModule);
     $this->runAsserts($aResultToAssert);
 }

 public function testModulesWithMissingFiles()
 {
     $this->markTestSkipped('Currently we are not checking module files.');
     // modules to be activated during test preparation
     $aInstallModules = array('with_1_extension', 'with_2_files');
     $oEnvironment = new Environment();
     $oEnvironment->prepare($aInstallModules);
     $oModuleList = oxNew('oxModuleList');
     $aGarbage = $oModuleList->getDeletedExtensions();
     $aExpect = array('with_1_extension' => array('extensions' => array('oxarticle' => 'with_1_extension/mybaseclass')), 'with_2_files' => array('files' => array('myexception' => 'with_2_files/core/exception/myexception.php', 'myconnection' => 'with_2_files/core/exception/myconnection.php')));
     $this->assertSame($aExpect, $aGarbage);
 }

 /**
  * Test check shop environment after module deactivation in subshop.
  *
  * @dataProvider providerModuleDeactivation
  *
  * @param array  $aInstallModules
  * @param string $sModuleId
  * @param array  $aResultToAssert
  */
 public function testModuleDeactivationInSubShop($aInstallModules, $sModuleId, $aResultToAssert)
 {
     if ($this->getTestConfig()->getShopEdition() != 'EE') {
         $this->markTestSkipped("This test case is only actual when SubShops are available.");
     }
     $oModule = oxNew('oxModule');
     $oEnvironment = new Environment();
     $oEnvironment->prepare($aInstallModules);
     $oEnvironment->setShopId(2);
     $oEnvironment->activateModules($aInstallModules);
     $this->deactivateModule($oModule, $sModuleId);
     $this->runAsserts($aResultToAssert);
 }

 /**
  * Test check shop module deactivation
  */
 public function testModuleDeactivate()
 {
     $oConfig = oxRegistry::getConfig();
     $sState = $oConfig->getConfigParam('sTestDeactivateEvent');
     $this->assertSame(null, $sState, 'No events should have been executed till now');
     $oEnvironment = new Environment();
     $oEnvironment->prepare(array('with_events'));
     $oModule = oxNew('oxModule');
     $oModule->load('with_events');
     $this->deactivateModule($oModule);
     $sState = $oConfig->getConfigParam('sTestDeactivateEvent');
     $this->assertEquals("Deactivate", $sState, 'onDeactivate event was not called.');
 }