Register paths to be published by the publish command.

@param  array  $paths
@param  string  $group
@return void
760163
protected function publishes(array $paths, $group = null)
	{
		$class = get_class($this);

		if ( ! array_key_exists($class, static::$publishes))
		{
			static::$publishes[$class] = [];
		}

		static::$publishes[$class] = array_merge(static::$publishes[$class], $paths);

		if ($group)
		{
			static::$publishGroups[$group] = $paths;
		}
	}
306256
public function setPaths($paths)
    {
        if (!is_array($paths) && !$paths instanceof Traversable) {
            throw new Exception\InvalidArgumentException(sprintf(
                'Invalid argument provided for $paths, expecting either an array or Traversable object, "%s" given',
                is_object($paths) ? get_class($paths) : gettype($paths)
            ));
        }

        $this->clearPaths();
        $this->addPaths($paths);
    }
1112473
protected function registerGroup($group = null, $action = [])
    {
        if ($group !== null) {
            $this->group = $group['action'];
        } elseif (is_array($action) && isset($action['_group'])) {
            $groups = RouteCollector::getGroups();
            $group = $action['_group'];
            $this->group = isset($groups[$group]) ? $groups[$group] : null;
        }
    }
749863
public function register_namespace( $namespace, $paths )
    {
        if ( isset( $this->namespaces[ $namespace ] ) )
        {
            $this->namespaces[ $namespace ] = array_merge(
                $this->namespaces[ $namespace ],
                (array) $paths
            );
        } 
        else 
        {
            $this->namespaces[ $namespace ] = (array) $paths;
            
            // Register PSR_0 as the first autoload filter for every namespace
            $this->register_autoload_filter( $namespace, array( $this, "PSR_0" ) );
        }
    }
1097713
protected function addGroups(Collection $groups)
    {
        foreach ($groups as $group) {
            $this->groups[] = $group->token;
            $this->addRoles($group->roles);
            $this->addPermissions($group->permissions);
        }
    }
1090182
public static function addPath($path)
    {
        if ( ! isset(self::$_messagePaths[$path]))
        {
            self::$_messagePaths[$path] = $path;
        }
    }
1070295
public function addGroup(Group $group)
    {
        $this->hasGroupsProperty();

        if (!$this->groups->contains($group)) {
            $this->groups->add($group);
        }
    }
921380
protected function configureDefinitions(array $group)
    {
        foreach ($group as $name => $dependencies)
        {
            $this->definition($name, $dependencies);
        }
    }
20911
public static function addIncludePath(...$path): void
    {
        $paths = explode(PATH_SEPARATOR, get_include_path());

        foreach ($path as $r) {

            if (is_array($r)) {
                foreach ($r as $t) {
                    $paths[] = $t;
                }
            } else {
                $paths[] = $r;
            }
        }

        set_include_path(implode(PATH_SEPARATOR, array_unique($paths)));
    }
1351789
public function addSerializerGroup($group)
    {
        if (is_array($group)) {
            $this->serializerGroups = array_merge(
                $this->serializerGroups,
                $group
            );
        } else {
            $this->serializerGroups[$group] = $group;
        }
    }
311545
public function addPath($path, $clearCache = true, $group = '__DEFAULT__')
	{
		//var_dump(func_get_args());
		$path = $this->normalizePath($path);

		// This is done for easy reference and
		// eliminates the need to check for doubles
		$this->paths[$group][$path] = $path;

		if ($clearCache)
		{
			$this->cache = [];
		}
	}
304455
protected function publishGroups()
    {
        // Config files
        $this->publishes([
            __DIR__.'/../config/auth.php' => config_path('nodes/api/auth.php'),
            __DIR__.'/../config/email-verification.php' => config_path('nodes/api/email-verification.php'),
            __DIR__.'/../config/errors.php' => config_path('nodes/api/errors.php'),
            __DIR__.'/../config/middleware.php' => config_path('nodes/api/middleware.php'),
            __DIR__.'/../config/reset-password.php' => config_path('nodes/api/reset-password.php'),
            __DIR__.'/../config/response.php' => config_path('nodes/api/response.php'),
            __DIR__.'/../config/settings.php' => config_path('nodes/api/settings.php'),
            __DIR__.'/../config/throttling.php' => config_path('nodes/api/throttling.php'),
            __DIR__.'/../config/transformer.php' => config_path('nodes/api/transformer.php'),
        ], 'config');
    }
1120042
private function chgrp(string $path, int $group): bool
    {
        if (!@chgrp($path, $group)) {
            $message = 'Could not change file group.';
            if ($error = error_get_last()) {
                $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
            }
            throw new FileException($message);
        }

        return true;
    }
971185
public static function addPath($path)
    {
        if (!in_array($path, self::$paths)) {
            array_unshift(self::$paths, $path);
        }
    }
809824
public function setGroups(array $groups) {
		foreach ($groups as $title => $path) {
			$this->setGroup($title, $path);
		}
	}
359198
protected function loadPath($path, $locale, $group)
    {
        $result = parent::loadPath($path, $locale, $group);

        if (empty($result) && str_contains($locale, '-')) {
            return parent::loadPath($path, strstr($locale, '-', true), $group);
        }

        return $result;
    }
302455
public static function addPsr4($paths)
    {
        $loader = new ClassLoader();

        foreach ($paths as $namespace => $path) {
            $loader->addPsr4($namespace, $path);
        }

        $loader->register();
    }