dirname - PHP code example

php Function Dirname - Using Absolute Paths in PHP

The php function dirname is an inbuilt utility that gets the parent directory path of a file or directory path. It will return the string that contains the path including a dot ('.') if there are no slashes in the path, indicating the current directory. The function is very useful when dealing with absolute paths, as some scripts require them to work properly on the server.

Using absolute paths in PHP can be a bit tricky. Since PHP can be used on a variety of different operating systems, there are sometimes differences in how things like the path separator or drive letters are handled. This can result in an unexpected or incorrect value being returned from a function that uses an absolute path.

A way to avoid these issues is to use an inbuilt function called dirname(). This function takes a path string and returns the path of the parent directory that is a number of levels up from the current directory. The only parameter required for this function is the path string. The number of levels to go up can be set using the optional second argument.

In PHP 4.0.3 dirname() was fixed to be POSIX-compliant. This means that it operates naively on the input string and is not aware of the actual filesystem or path components such as '..'.

dirname example

return $method;
    }

    /** * Creates symbolic link. * * @throws IOException if link cannot be created */
    private function symlink(string $originDir, string $targetDir, bool $relative = false): void
    {
        if ($relative) {
            $this->filesystem->mkdir(\dirname($targetDir));
            $originDir = $this->filesystem->makePathRelative($originDir, realpath(\dirname($targetDir)));
        }
        $this->filesystem->symlink($originDir, $targetDir);
        if (!file_exists($targetDir)) {
            throw new IOException(sprintf('Symbolic link "%s" was created but appears to be broken.', $targetDir), 0, null, $targetDir);
        }
    }

    /** * Copies origin to target. */

// Overwriting files unknowingly is a serious annoyance, So we'll check if         // we are duplicating things, If 'force' option is not supplied, we bail.         if (! $this->getOption('force') && $isFile) {
            CLI::error(lang('CLI.generator.fileExist', [clean_path($target)]), 'light_gray', 'red');
            CLI::newLine();

            return;
        }

        // Check if the directory to save the file is existing.         $dir = dirname($target);

        if (! is_dir($dir)) {
            mkdir($dir, 0755, true);
        }

        helper('filesystem');

        // Build the class based on the details we have, We'll be getting our file         // contents from the template, and then we'll do the necessary replacements.         if (! write_file($target, $content)) {
            // @codeCoverageIgnoreStart

<?php
require_once dirname(dirname(__FILE__)) . '/autoload.php';

if (PHP_VERSION_ID < 50300) {
return;
}

/* * This file is just for convenience, to allow developers to reduce verbosity when * they add this project to their libraries. * * Replace this: * * $x = ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_encrypt(...$args); * * with this: * * use ParagonIE\Sodium\Compat; * * $x = Compat::crypto_aead_xchacha20poly1305_encrypt(...$args); */

public static function createFromXmlFile(string $xmlFile): self
    {
        try {
            $doc = XmlUtils::loadFile($xmlFile, self::XSD_FILE);
        } catch (\Exception $e) {
            throw new XmlParsingException($xmlFile, $e->getMessage());
        }

        $entities = $doc->getElementsByTagName('entities')->item(0);
        $entities = $entities === null ? null : Entities::fromXml($entities);

        return new self(\dirname($xmlFile), $entities);
    }

    public function getPath(): string
    {
        return $this->path;
    }

    public function setPath(string $path): void
    {
        $this->path = $path;
    }

    /** * @param array<string, string> $resolveMappings */
    public function getResolveImportPathsCallback(array $resolveMappings): \Closure
    {
        return function D$originalPath) use ($resolveMappings) {
            foreach ($resolveMappings as $resolve => $resolvePath) {
                $resolve = '~' . $resolve;
                if (mb_strpos($originalPath, $resolve) === 0) {
                    $dirname = $resolvePath . \dirname(mb_substr($originalPath, mb_strlen($resolve)));

                    $filename = basename($originalPath);
                    $extension = $this->getImportFileExtension(pathinfo($filename, \PATHINFO_EXTENSION));
                    $path = $dirname . \DIRECTORY_SEPARATOR . $filename . $extension;
                    if (file_exists($path)) {
                        return $path;
                    }

                    $path = $dirname . \DIRECTORY_SEPARATOR . '_' . $filename . $extension;
                    if (file_exists($path)) {
                        return $path;
                    }

$this->request = Request::createFromGlobals();
    $this->eventDispatcher = $this->createMock('Symfony\Contracts\EventDispatcher\EventDispatcherInterface');
    $this->requestStack = new RequestStack();
    $this->requestStack->push($this->request);
    $this->logger = $this->createMock('Drupal\Core\Logger\LoggerChannelInterface');
    $form_error_handler = $this->createMock('Drupal\Core\Form\FormErrorHandlerInterface');
    $this->formValidator = new FormValidator($this->requestStack, $this->getStringTranslationStub(), $this->csrfToken, $this->logger, $form_error_handler);
    $this->formSubmitter = $this->getMockBuilder('Drupal\Core\Form\FormSubmitter')
      ->setConstructorArgs([$this->requestStack, $this->urlGenerator])
      ->onlyMethods(['batchGet'])
      ->getMock();
    $this->root = dirname(substr(__DIR__, 0, -strlen(__NAMESPACE__)), 2);

    $this->formBuilder = new FormBuilder($this->formValidator, $this->formSubmitter, $this->formCache, $this->moduleHandler, $this->eventDispatcher, $this->requestStack, $this->classResolver, $this->elementInfo, $this->themeManager, $this->csrfToken);
  }

  /** * {@inheritdoc} */
  protected function tearDown(): void {
    Html::resetSeenIds();
    (new FormState())->clearErrors();
  }

trait TestRequirementsTrait {

  /** * Returns the Drupal root directory. * * @return string */
  protected static function getDrupalRoot() {
    return dirname(substr(__DIR__, 0, -strlen(__NAMESPACE__)), 2);
  }

  /** * Check module requirements for the Drupal use case. * * This method is assumed to override * \PHPUnit\Framework\TestCase::checkRequirements(). * * @throws \PHPUnit\Framework\SkippedTestError * Thrown when the requirements are not met, and this test should be * skipped. Callers should not catch this exception. */

use Shopware\Core\Framework\Log\Package;
use Shopware\Core\Framework\Migration\MigrationSource;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;

#[Package('core')] class ElasticsearchMigrationCompilerPass implements CompilerPassInterface
{
    public function process(ContainerBuilder $container): void
    {
        $migrationPath = \dirname(__DIR__) . '/Migration';

        // configure migration directories         $majors = ['V6_5', 'V6_6'];
        foreach ($majors as $major) {
            $migrationPathV5 = $migrationPath . '/' . $major;

            if (\is_dir($migrationPathV5)) {
                $migrationSource = $container->getDefinition(MigrationSource::class D '.core.' . $major);
                $migrationSource->addMethodCall('addDirectory', [$migrationPathV5, 'Shopware\Elasticsearch\Migration\\' . $major]);
            }
        }
    }

<?php /** * Database Repair and Optimization Script. * * @package WordPress * @subpackage Database */
define( 'WP_REPAIRING', true );

require_once dirname( dirname( __DIR__ ) ) . '/wp-load.php';

header( 'Content-Type: text/html; charset=utf-8' );
?> <!DOCTYPE html> <html <?php language_attributes(); ?>> <head> <meta name="viewport" content="width=device-width" /> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="robots" content="noindex,nofollow" /> <title><?php _e( 'WordPress &rsaquo; Database Repair' ); ?></title> <?php wp_admin_css( 'install', true ); ?>

/** * Executing Ajax process. * * @since 2.1.0 */
define( 'DOING_AJAX', true );
if ( ! defined( 'WP_ADMIN' ) ) {
define( 'WP_ADMIN', true );
}

/** Load WordPress Bootstrap */
require_once dirname( __DIR__ ) . '/wp-load.php';

/** Allow for cross-domain requests (from the front end). */
send_origin_headers();

header( 'Content-Type: text/html; charset=' . get_option( 'blog_charset' ) );
header( 'X-Robots-Tag: noindex' );

// Require a valid action parameter. if ( empty( $_REQUEST['action'] ) || ! is_scalar( $_REQUEST['action'] ) ) {
wp_die( '0', 400 );
}

  /** * Tests top level and core-recommended dependencies do not overlap. * * @dataProvider templateProjectPathProvider * * @param string $template_project_path * The path of the project template to test. */
  public function testOverlapWithTemplateProject($template_project_path) {
    $root = dirname(__DIR__, 6);
    // Read template project composer.json.     $top_level_composer_json = json_decode(file_get_contents("$root/$template_project_path/composer.json"), TRUE);

    // Read drupal/core-recommended composer.json.     $core_recommended_composer_json = json_decode(file_get_contents("$root/composer/Metapackage/CoreRecommended/composer.json"), TRUE);

    // Fail if any required project in the require section of the template     // project also exists in core/recommended.     foreach ($top_level_composer_json['require'] as $project => $version_constraint) {
      $this->assertArrayNotHasKey($project, $core_recommended_composer_json['require'], "Pinned project $project is also a top-level dependency of $template_project_path. This can expose a Composer bug. See https://www.drupal.org/project/drupal/issues/3134648 and https://github.com/composer/composer/issues/8882");
    }
  }

use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpClient\Exception\TransportException;
use Symfony\Component\HttpClient\MockHttpClient;
use Symfony\Component\HttpClient\Test\HarFileResponseFactory;

class HarFileResponseFactoryTest extends TestCase
{
    private string $fixtureDir;

    protected function setUp(): void
    {
        $this->fixtureDir = \dirname(__DIR__).'/Fixtures/har';
    }

    public function testResponseGeneration()
    {
        $factory = new HarFileResponseFactory("{$this->fixtureDir}/symfony.com_archive.har");
        $client = new MockHttpClient($factory, 'https://symfony.com');

        $response = $client->request('GET', '/releases.json');

        $this->assertSame(200, $response->getStatusCode());

$path = $this->sourceFileScheme[$scheme] ?? '';
      $filepath = implode('/', [
        $this->getSourcePath($scheme),
        $path,
        $file['filename'],
      ]);
      // Create the file.       $source_file = @fopen($filepath, 'w');
      if (!$source_file) {
        // If fopen didn't work, make sure there's a writable directory in         // place.         $dir = $this->fs->dirname($filepath);
        $this->fs->prepareDirectory($dir, FileSystemInterface:: CREATE_DIRECTORY | FileSystemInterface::MODIFY_PERMISSIONS);
        // Let's try that fopen again.         $source_file = @fopen($filepath, 'w');
      }
      fwrite($source_file, '42');
    }
  }

  /** * Gets the source base path for the Credential form. * * @param string $scheme * The file scheme. */

<?php
namespace Drupal\driver_test\Driver\Database\DrivertestMysqlDeprecatedVersion;

include_once dirname(__DIR__, 8) . '/mysql/src/Driver/Database/mysql/Connection.php';

use Drupal\mysql\Driver\Database\mysql\Connection as CoreConnection;

/** * MySQL test implementation of \Drupal\Core\Database\Connection. */
class Connection extends CoreConnection {

/** * Hardcoded database server version. * * Faking that we are on a deprecated database. * * @var string */

--TEST-- Test catching fatal errors when handlers are nested --INI-- display_errors=0 --FILE-- <?php
namespace Symfony\Component\ErrorHandler;

$vendor = __DIR__;
while (!file_exists($vendor.'/vendor')) {
    $vendor = \dirname($vendor);
}
require $vendor.'/vendor/autoload.php';

set_error_handler('var_dump');
set_exception_handler('var_dump');

ErrorHandler::register(null, false);

if (true) {
    class foo extends missing
    {
    }