Add new helper group namespace.

@param string $name
@return bool
976362
public function addNamespace($name)
    {
        if (!Arr::in($name, self::$_namespace)) {
            self::$_namespace[] = $name;
            return true;
        }

        return false;
    }
1027922
public function addWatch($name)
    {
        if (array_key_exists($name, $this->timers)) {
            return false;
        }

        $watch = new Timer($name);
        $this->timers[$name] = $watch;

        return true;
    }
557050
public function addGroup($group) {
    if (!$group->inArray((array) $this->groups)) {
      $this->groups[] = $group;
      return $this->groups;
    }
    return true;
  }
895213
public function findByName($name)
	{
		$model = $this->createModel();

		if ( ! $group = $model->newQuery()->where('name', '=', $name)->first())
		{
			throw new GroupNotFoundException("A group could not be found with the name [$name].");
		}

		return $group;
	}
741471
public function addNameIfNotExists($name) {
    if (!isset($this->children[$name])) {
      $this->internalAddName($name);
    }
    return $this;
  }
909442
public function addName($name)
    {
        if (!in_array('names', $this->setFields)) {
            $this->setFields[] = 'names';
        }
        $this->names[] = $name;

        return $this;
    }
415312
public static function create($namespace = null, $name = null)
    {
        if (null === $namespace) {
            return self::createNamespacelessUuid();
        }

        return self::createNamespacedUuid($namespace, $name);
    }
1292611
public function addHelper($name, $helper)
    {
        if ($this->mustache !== null) {
            throw new RuntimeException(
                'Can not add helper to Mustache engine: the engine has already been initialized.'
            );
        }

        $this->helpers[$name] = $helper;

        return $this;
    }
762967
protected function _t_loader_namespacestack_fixResourceList($name)
    {
        if (!is_array($this->_t_loader_namespacestack_Namespaces[$name]))
            $this->_t_loader_namespacestack_Namespaces[$name] = array(
                $this->_t_loader_namespacestack_Namespaces[$name]
            );
    }
971297
public function addGroup($name, $fields = [])
    {
        $group = new Group();
        $group->setName($name);
        $group->setFields($fields);
        $this->addGroupObject($group);
    }
863616
private function add(string $name) : bool
  {
    $appdir = ModulusCLI::$appdir . 'app';
    $app = $appdir . DIRECTORY_SEPARATOR . $name . '.php';
    $namespace = '';

    if (substr_count($name, '/') > 0) {
      ModulusCLI::_dir(substr($app, 0, strrpos($app, DIRECTORY_SEPARATOR)));
      $namespace = substr($name, 0, strrpos($name, DIRECTORY_SEPARATOR));
      $name = str_replace($namespace . DIRECTORY_SEPARATOR, '', $name);

      $namespace = '\\' . str_replace('/', '\\', $namespace);
    }

    ModulusCLI::_dir($appdir);

    $content = Template::asset('trait_template');
    $content = str_replace('{name}', $name, $content);
    $content = str_replace('{namespace}', $namespace, $content);

    if (file_exists($app)) {
      return false;
    }
    else {
      file_put_contents($app, $content);
      return true;
    }
  }
647712
public function add($name, $value)
    {
        $this->arguments[] = '--add';
        $this->arguments[] = $name;
        $this->arguments[] = $value;
        return $this;
    }
198937
protected function _addNamespaces($names, array $namespaces, array &$logs = array())
    {
        if (!is_array($names)) {
            $names = array($names);
        }
        $return_names = array();
        foreach ($names as $_name) {
            foreach ($namespaces as $_namespace) {
                if (CodeHelper::namespaceExists($_namespace)) {
                    $tmp_namespace = rtrim(TextHelper::toCamelCase($_namespace), '\\').'\\';
                    $return_names[] = $tmp_namespace.str_replace($tmp_namespace, '', TextHelper::toCamelCase($_name));
                } else {
                    $logs[] = $this->_getErrorMessage('Namespace "%s" not found!', $_namespace);
                }
            }
        }
        return $return_names;
    }
38901
public function addToGroup($groupName, $elementName = '')
    {

		if(isset($this->groups[$groupName])){
			if(isset($this->groups[$groupName]['elements'])){
				if(!in_array($elementName, $this->groups[$groupName]['elements'])){
					$this->groups[$groupName]['elements'][] = $elementName;
				}
			}
		}

    }
370212
public static function registerHelper($name, $helper)
    {
        Argument::i()
            //Argument 1 must be a string
            ->test(1, 'string')
            //Argument 2 must be a Closure of some kind
            ->test(2, 'Closure');
        
        self::$helpers[$name] = $helper;
    }
333566
public function group($name)
    {
        $this->_pointers['group'] = $name;
        $this->_menu[$this->_pointers['node']]['groups'][$name] = ['name' => $name, 'items' => []];
    
        return $this;
    }
1038887
protected function addRole($groupName, $name)
    {

        // load the application
        $application = RequestHandler::getApplicationContext();

        // query whether or not, the group already exists
        if ($this->setsMap->exists($groupName) === false) {
            $group = new SimpleGroup(new String($groupName));
            $this->setsMap->add($groupName, $group);
        } else {
            $group = $this->setsMap->get($groupName);
        }

        try {
            // finally add the identity to the group
            $group->addMember($this->createIdentity(new String($name)));

        } catch (\Exception $e) {
            $application->getNamingDirectory()
                        ->search(NamingDirectoryKeys::SYSTEM_LOGGER)
                        ->error($e->__toString());
        }
    }