Override path convention (because settings is a virtual admin subtree)

@param string $suffix

@return string
357160
public function getPathByConvention($suffix = null)
    {
        if (empty($suffix)) {
            return sprintf('%s_nodes', $this->getBundleName());
        }

        return sprintf('%s_nodes_%s', $this->getBundleName(), $suffix);
    }
792611
public function setContextualClassSuffix($suffix)
    {
        $this->attributes->removeAttributeClass([
            $this->contextualClassPrefix . '-' . 'default',
            $this->contextualClassPrefix . '-' . 'primary',
            $this->contextualClassPrefix . '-' . 'secondary',
            $this->contextualClassPrefix . '-' . 'success',
            $this->contextualClassPrefix . '-' . 'info',
            $this->contextualClassPrefix . '-' . 'warning',
            $this->contextualClassPrefix . '-' . 'danger',
            $this->contextualClassPrefix . '-' . 'neutral',
        ]);
        $this->attributes->addAttributeClass($this->contextualClassPrefix . '-' . $suffix);

        return $this;
    }
1041901
def add_suffix(filename, suffix):
        
        path = filename.split("/")
        parts = path[-1].split(".")
        i = max(len(parts) - 2, 0)
        parts[i] = parts[i] + suffix
        path[-1] = ".".join(parts)
        return "/".join(path)
347606
public static function addSuffix(string $value, string $suffix): string
    {
        return self::removeSuffix($value, $suffix).$suffix;
    }
336695
public static function getClassShortName(
        string $class,
        string $suffix = ''
    ): string {
        $baseName = static::getClassBaseName($class);

        return preg_replace(sprintf('/%s$/', $suffix), '', $baseName);
    }
174026
public function getName( $suffix = NULL ) : string
    {
        $name = $suffix ? basename( $this->path, $suffix ) : basename( $this->path );

        return $name;
    }
1010430
protected function getFilePath(string $file, ?string $extension = null, ?string $suffix = null): string
	{
		if(strpos($file, '::') === false)
		{
			// No namespace so we'll just use the default path

			$path = $this->path;
		}
		else
		{
			// The file is namespaced so we'll use the namespace path

			[$namespace, $file] = explode('::', $file, 2);

			if(!isset($this->namespaces[$namespace]))
			{
				throw new RuntimeException(vsprintf('The [ %s ] namespace does not exist.', [$namespace]));
			}

			$path = $this->namespaces[$namespace];
		}

		// Append suffix to path if needed

		if($suffix !== null)
		{
			$path .= DIRECTORY_SEPARATOR . $suffix;
		}

		// Return full path to file

		return $path . DIRECTORY_SEPARATOR . str_replace('.', DIRECTORY_SEPARATOR, $file) . ($extension ?? $this->extension);
	}
532515
private function stringEndsWith(string $string, string $suffix): bool
    {
        return substr($string, -strlen($suffix)) === $suffix;
    }
887343
public function endsWithIgnoreCase($suffix) {
		$other = new Str($suffix, $this->charset);

		return mb_strripos($this->rawString, $suffix, 0, $this->charset) === ($this->length() - $other->length());
	}
611009
public function addSuffix($suffix)
	{
		if (!in_array($suffix, $this->suffixes))
		{
			array_push($this->suffixes, trim($suffix));
		}

		return $this;
	}
504102
protected function buildCoalescedStrings(array $prefixStrings, array $suffix)
	{
		$strings = $this->runPass($this->buildPrefix($prefixStrings));
		if (count($strings) === 1 && $strings[0][0][0] === [])
		{
			// If the prefix has been remerged into a list of strings which contains only one string
			// of which the first element is an optional alternations, we only need to append the
			// suffix
			$strings[0][] = $suffix;
		}
		else
		{
			// Put the current list of strings that form the prefix into a new list of strings, of
			// which the only string is composed of our optional prefix followed by the suffix
			array_unshift($strings, []);
			$strings = [[$strings, $suffix]];
		}

		return $strings;
	}
732829
public function cropSuffix(string $fqn, string $suffix): string
    {
        if ($suffix === \substr($fqn, -\strlen($suffix))) {
            return \substr($fqn, 0, -\strlen($suffix));
        }

        return $fqn;
    }
1182013
public static function removeSuffix($string, $suffix)
    {
        if (self::endsWith($string, $suffix)) {
            return mb_substr($string, 0, -mb_strlen($suffix));
        }
        return $string;
    }
1368293
public function getId($suffix = null)
    {
        $id = parent::getId($suffix);
        $id .= '-' . $this->fieldName;
        return HtmlHelper::nameToId($id);
    }
253860
public function getBasename($suffix = null)
    {
        if (is_null($suffix)) {
            return parent::getBasename();
        }

        return str_replace('.' . $this->getExtension(), '.' . trim($suffix, '.'), parent::getFilename());
    }
1208408
public function resolveExtension()
    {
        if (($pos = strrpos($this->path, '.')) !== false) {
            return substr($this->path, $pos + 1);
        }

        return '';
    }
257104
public function getId($suffix = null)
    {
        $id = class_basename(get_called_class()) . '-' . $this->action;
        if ($suffix !== null) {
            $id .= '-' . $suffix;
        }

        return $id;
    }