Sets the path of the SonarQube Scanner executable.

If the SonarQube Scanner is included in the PATH environment variable,
the file name is sufficient.

@param  string $executable
@return void
772815
public function setExecutable($executable)
    {
        $this->executable = (string) $executable;

        $message = sprintf("Set executable to [%s].", $this->executable);
        $this->log($message, Project::MSG_DEBUG);
    }
982151
public function setPaths($paths)
    {
        $this->paths = $paths;
        self::$pathsMap[$this->namespace] = $this->paths;
    }
1330015
static function setControllerPath($dir)
    {
        if (is_dir($dir))
        {
            self::$controller_path = $dir;
        }
        else
        {
            \Swoole\Error::info("fatal error", "controller_path[$dir] is not exists.");
        }
    }
277193
private function setPath($path)
    {
        $this->info['path'] = $this->info['file'] = $this->info['extension'] = $this->info['content'] = null;

        if ($this->getScheme() === 'data') {
            $this->info['content'] = $path;

            return;
        }

        $file = substr(strrchr($path, '/'), 1);

        if (strlen($file)) {
            $path = substr($path, 0, -strlen($file));

            if (preg_match('/(.*)\.([\w]+)$/', $file, $match)) {
                $this->info['file'] = rawurldecode($match[1]);
                $this->info['extension'] = $match[2];
            } else {
                $this->info['file'] = rawurldecode($file);
            }
        }

        $this->info['path'] = [];

        foreach (explode('/', $path) as $dir) {
            $dir = rawurldecode($dir);

            if ($dir !== '') {
                $this->info['path'][] = $dir;
            }
        }
    }
1204527
private void createExecutableSettings()
	{

		executablePathLabel = new JLabel("Path to executables: ");
		executablePathLabel.setBounds(10, 10, 250, 25);
		this.add(executablePathLabel);

		// ------------------------------------------------------------------//
		// 7ZIP / P7ZIP SETTINGS //
		// ------------------------------------------------------------------//

		sevenZipEnableBox = new JCheckBox();
		sevenZipEnableBox.setBounds(10, 45, 25, 25);

		this.add(sevenZipEnableBox);

		sevenZipLabel = new JLabel("7Zip Executable: ");
		sevenZipLabel.setBorder(BorderFactory.createRaisedBevelBorder());
		sevenZipLabel.setBounds(40, 45, 120, 25);
		this.add(sevenZipLabel);

		sevenZipPathField = new JTextField();
		sevenZipPathField.setBounds(170, 45, 300, 25);
		this.add(sevenZipPathField);

		sevenZipSearchButton = new JButton("Search");
		sevenZipSearchButton.setBounds(480, 45, 80, 25);

		sevenZipSearchButton.addActionListener(new ActionListener()
		{
			@Override
			public void actionPerformed(final ActionEvent e)
			{

				JFileChooser fc = new JFileChooser();
				if (fc.showOpenDialog(new JPanel()) == JFileChooser.APPROVE_OPTION) {
					sevenZipPathField.setText(fc.getSelectedFile().getPath());
				}
			}
		});

		this.add(sevenZipSearchButton);

		sevenZipEnableBox.addActionListener(new ActionListener()
		{
			@Override
			public void actionPerformed(final ActionEvent e)
			{
				boolean flag = !controller.is7ZipEnabled();
				controller.setEnable7Zip(flag);

				sevenZipLabel.setEnabled(flag);
				sevenZipPathField.setEnabled(flag);
				sevenZipSearchButton.setEnabled(flag);
			}
		});

	}
732834
public function setLogPath(string $logPath) : void
    {
        if (!file_exists($logPath)) {
            throw new ManagerException('Invalid log path. Folder not found.');
        }
        $this->logPath = $logPath;
    }
545660
public function processFilesets(SassTaskCompiler $compiler): void
    {
        foreach ($this->filesets as $fs) {
            $ds = $fs->getDirectoryScanner($this->project);
            $files = $ds->getIncludedFiles();
            $dir = $fs->getDir($this->project)->getPath();

            // If output path isn't defined then set it to the path of our fileset.
            $specifiedOutputPath = (strlen($this->outputpath) > 0);
            if ($specifiedOutputPath === false) {
                $this->outputpath = $dir;
            }

            foreach ($files as $file) {
                $fullFilePath = $dir . DIRECTORY_SEPARATOR . $file;
                $this->pathInfo = pathinfo($file);

                $run = true;
                switch (strtolower($this->pathInfo['extension'])) {
                    case 'scss':
                    case 'sass':
                        break;
                    default:
                        $this->log('Ignoring ' . $file, Project::MSG_DEBUG);
                        $run = false;
                }

                if ($run
                    && ($this->extfilter === ''
                        || $this->extfilter === $this->pathInfo['extension'])
                ) {
                    $outputFile = $this->buildOutputFilePath();
                    $compiler->compile($fullFilePath, $outputFile, $this->failonerror);
                }
            }
        }
    }
1137938
protected function setCachePath()
    {
        $filename = basename($this->pathFile);

        $this->pathCache = $this->cacheDir . '/' . $filename;
    }
682363
public function setPath($path = '')
    {
        if (is_dir($path)) {
            $this->path = $path;
        } elseif (defined('PATH_STORAGE')) {
            if (is_dir($path)) {
                $this->path = $path;
            } else {
                $this->path = PATH_STORAGE . str_replace(PATH_STORAGE, '', $path);
            }
        } else {
            $this->path = dirname($_SERVER[ 'SCRIPT_FILENAME' ]) . DIRECTORY_SEPARATOR . $path;
        }
    }
32586
public function setPath($path = null)
    {
        if (is_string($path)) {
            if ($path{0} !== '/') {
                $path = "/$path";
            }
        }
        else if (!is_null($path)) {
            throw new \InvalidArgumentException(
                "invalid value provided for 'path'; ".
                " expecting a string or null"
            );
        }
        $this->path = $path;
    }
326481
protected function setPath($path)
    {
        if ($path !== '' && !$this->isValidPath($path)) {
            throw new \InvalidArgumentException("Invalid path '$path'");
        }
        
        $this->path = (string)$path;
    }
285746
@Restricted(NoExternalUse.class)
    public void setExecutable(Executable executable) {
        this.executable = executable;
        if (executable instanceof Run) {
            ((Run) executable).setQueueId(context.item.getId());
        }
    }
18456
public function set($orig, $dest='')
    {
        if(!empty($dest)){
            copy($orig, $dest);
            $orig = $dest;
        }

        $this->path = $orig;
        $this->getInfo();

    }
375953
private function setPath($path)
    {
        $parts = pathinfo($path);

        $this->info['path'] = [];

        if (isset($parts['dirname'])) {
            foreach (explode('/', str_replace(DIRECTORY_SEPARATOR, '/', $parts['dirname'])) as $dir) {
                if ($dir !== '') {
                    $this->info['path'][] = $dir;
                }
            }
        }

        $this->info['file'] = isset($parts['filename']) ? $parts['filename'] : null;
        $this->info['extension'] = isset($parts['extension']) ? $parts['extension'] : null;
    }
621430
public function setEnvironment($environment)
	{
		if ($environment)
		{
			$environment = trim($environment, DIRECTORY_SEPARATOR);
		}

		$this->environment = $environment;
	}
1214714
private function setExitCode(ExecutableTest $test)
    {
        $exit = $test->getExitCode();
        if ($exit > $this->exitcode) {
            $this->exitcode = $exit;
        }
    }
628202
public function setToolpath($path)
    {
        if (!file_exists($path)) {
            $fs = FileSystem::getFileSystem();
            $fullpath = $fs->which($path);
            if ($fullpath === false) {
                throw new BuildException(
                    'Tool does not exist. Path: ' . $path
                );
            }
            $path = $fullpath;
        }
        if (!is_executable($path)) {
            throw new BuildException(
                'Tool not executable. Path: ' . $path
            );
        }
        $this->toolPath = $path;
    }