/**
  * @covers Xoops\Form\Token::__construct
  * @covers Xoops\Form\Token::render
  */
 public function test__construct()
 {
     // '<input hidden type="hidden" name="XOOPS_TOKEN_REQUEST" value="'
     $oldWay = new Token();
     $newWay = new Token([]);
     $this->assertEquals(substr($oldWay->render(), 0, 62), substr($newWay->render(), 0, 62));
 }

 /**
  * Verificação da Precedência
  * @param Token $tokenA Token para Verificação
  * @param Token $tokenB Token para Verificação
  * @throws Exception Token de Tipo Não Operador
  * @return int Comparação de Precedências dos Tokens
  */
 public function precedence($tokenA, $tokenB)
 {
     /* @todo Checar Precedência */
     $precedenceA = $this->_mapper[$tokenA->getContent()];
     $precedenceB = $this->_mapper[$tokenB->getContent()];
     return $precedenceA - $precedenceB;
 }

 /**
  * @param int $userId
  * @param string $token
  * @return Token
  */
 public static function createToken($userId, $token)
 {
     $newToken = new Token();
     $newToken->setUserId($userId);
     $newToken->setToken($token);
     return $newToken;
 }

 public function postRegistro()
 {
     $input = Input::all();
     $reglas = array('nombre' => 'required', 'apellido' => 'required', 'celular' => 'required|numeric|unique:users', 'cedula' => 'required|numeric|unique:users', 'email' => 'required|email|unique:users', 'pin' => 'required|numeric|digits_between:0,4', 'password' => 'required|numbers|case_diff|letters|min:6|confirmed', 'password_confirmation' => 'required|min:6');
     $validation = Validator::make($input, $reglas);
     if ($validation->fails()) {
         return Response::json(['success' => false, 'errors' => $validation->errors()->toArray()]);
     }
     try {
         // se guarda los datos del usuario
         $user = Sentry::register(array('first_name' => Input::get('nombre'), 'last_name' => Input::get('apellido'), 'email' => Input::get('email'), 'habilitar_pin' => 1, 'celular' => Input::get('celular'), 'cedula' => Input::get('cedula'), 'password' => Input::get('password'), 'pin' => Input::get('pin'), 'porcentaje' => 0.05, 'activated' => true));
         $userId = $user->getId();
         $token = new Token();
         $token->user_id = $userId;
         $token->api_token = hash('sha256', Str::random(10), false);
         $token->client = BrowserDetect::toString();
         $token->expires_on = Carbon::now()->addMonth()->toDateTimeString();
         $token->save();
         // Se autentica de una
         $user_login = Sentry::findUserById($userId);
         Sentry::login($user_login, false);
         return Response::json(['success' => true, 'user' => $user_login, 'token' => $token->api_token]);
     } catch (Cartalyst\Sentry\Users\LoginRequiredException $e) {
         $error = array('usuario' => 'Email es requerido');
     } catch (Cartalyst\Sentry\Users\PasswordRequiredException $e) {
         $error = array('usuario' => 'Password es requerido');
     } catch (Cartalyst\Sentry\Users\UserExistsException $e) {
         $error = array('usuario' => 'El Email ya está registrado');
     }
     return Response::json(['success' => false, 'errors' => $error]);
 }

 public static function conjure($token, TokenSet $tokenSet, TokenOutput $tokenOutput = null)
 {
     if (is_array($token)) {
         switch ($token[0]) {
             case T_INTERFACE:
                 $t = new InterfaceToken($token, $tokenSet);
                 break;
             case T_CLASS:
                 $t = new ClassToken($token, $tokenSet);
                 break;
             case T_FUNCTION:
                 $t = new FunctionToken($token, $tokenSet);
                 break;
             default:
                 // fall through to regular Token
                 $t = new Token($token, $tokenSet);
         }
     } else {
         // fall through to regular Token
         $t = new Token($token, $tokenSet);
     }
     if ($tokenOutput == null) {
         $tokenOutput = new TextTokenOutput();
     }
     $t->setOutput($tokenOutput);
     return $t;
 }

 public function test1()
 {
     // TODO make proper test
     $tok = new Token();
     $val = $tok->generate(1000, 'bajs');
     echo $val . "\n";
 }

 /**
  * @param integer $steps
  * @param Token $token
  *
  * @return $this
  */
 protected function occupy($steps, Token $token)
 {
     if ($token->owner()->equals($this->homeSquares->owner())) {
         return $this->homeSquares->occupy(--$steps, $token);
     }
     return parent::occupy($steps, $token);
 }

 public function testIsExpired()
 {
     $token = new Token(array('access_token' => '', 'refresh_token' => '', 'expires_in' => 5));
     $this->assertFalse($token->isExpired());
     $token = new Token(array('access_token' => '', 'refresh_token' => '', 'expires_in' => -5));
     $this->assertTrue($token->isExpired());
 }

 /**
  * Simply attempts to attract place names or names.
  */
 private function extract_potential_named_entities()
 {
     for ($i = 0, $n = count($this->tokens); $i < $n; $i++) {
         $entity = NULL;
         $token = new Token($this->tokens[$i]);
         // If the token is uppercase, maybe it is a name or a place.
         if ($token->isUpperCase() && !$token->isStopWord() && !$token->isInitWord()) {
             $entity = array($token->getText());
             // Look two words ahead.
             if (isset($this->tokens[$i + 2])) {
                 $next = new Token($this->tokens[$i + 2]);
                 while ($next->isUpperCase() || $next->isPrefixOrInfix()) {
                     // Jump two words.
                     $i += 2;
                     $entity[] = $next->getText();
                     if (isset($this->tokens[$i + 2])) {
                         $next = new Token($this->tokens[$i + 2]);
                     } else {
                         break;
                     }
                 }
             }
             $this->named_entities[] = $entity;
         }
     }
 }

 /**
  * Reads the next token from the INI file
  *
  * @throws  IOException     On error
  * @return Token
  */
 function readToken()
 {
     if ($this->file === null) {
         throw new BuildException("No File set for IniFileTokenReader");
     }
     static $tokens = null;
     if ($tokens === null) {
         $tokens = array();
         $arr = parse_ini_file($this->file->getAbsolutePath(), true);
         if ($this->section === null) {
             foreach ($arr as $sec_name => $values) {
                 foreach ($arr[$sec_name] as $key => $value) {
                     $tok = new Token();
                     $tok->setKey($key);
                     $tok->setValue($value);
                     $tokens[] = $tok;
                 }
             }
         } else {
             if (isset($arr[$this->section])) {
                 foreach ($arr[$this->section] as $key => $value) {
                     $tok = new Token();
                     $tok->setKey($key);
                     $tok->setValue($value);
                     $tokens[] = $tok;
                 }
             }
         }
     }
     if (count($tokens) > 0) {
         return array_pop($tokens);
     } else {
         return null;
     }
 }

 /**
  * @param integer $user_id
  * @return Token
  */
 public function createAutologinToken($user_id)
 {
     $token = new Token();
     $token->setUserId($user_id);
     $token->setAction(Token::$ACTION_AUTOLOGIN);
     return $token;
 }

 /**
  * @covers Xoops\Form\Token::render
  */
 public function testRender()
 {
     $value = $this->object->render();
     $this->assertTrue(is_string($value));
     $this->assertTrue(false !== strpos($value, '<input'));
     $this->assertTrue(false !== strpos($value, 'type="hidden"'));
     $this->assertTrue(false !== strpos($value, 'name="XOOPS_TOKEN_REQUEST"'));
 }

 /**
  * Sign the Request with a Token
  *
  * @param Token  $token
  * @param string $prefix
  * @return array
  */
 public function sign(Token $token, $prefix = self::PREFIX)
 {
     $auth = [$prefix . 'version' => self::VERSION, $prefix . 'key' => $token->key(), $prefix . 'timestamp' => $this->timestamp];
     $payload = $this->payload($auth, $this->params);
     $signature = $this->signature($payload, $this->method, $this->uri, $token->secret());
     $auth[$prefix . 'signature'] = $signature;
     return $auth;
 }

 protected function _getParseTokenFromToken(Token $token)
 {
     $code = $token->getCode();
     if ($code === "WHILE_START") {
         $code = "WHILE";
     }
     return new ParseToken($code, $token->getContent(), $token->getChar(), $token->getLine());
 }

 /**
  * @param array $params Parameters for creating an account
  *                      username, password, email are required
  *                      language, first_name, last_name are optional
  * @return array
  */
 public function create($params)
 {
     $params = $this->filter_parameters($params, array('username', 'password', 'first_name', 'last_name', 'email', 'language'));
     $v = new \Valitron\Validator($params);
     $v->rules(['required' => [['username'], ['password'], ['email'], ['language']]]);
     $used_values = null;
     $return_errors = null;
     if ($v->validate()) {
         if ($this->get_user_id($params['username']) !== false) {
             $used_values[] = 'username';
         }
         if ($this->email_used($params['email'])) {
             $used_values[] = 'email';
         }
         if ($used_values === null) {
             $v->rule('email', 'email');
             if ($v->validate()) {
                 $v->rules(['lengthMax' => [['username', 20]]]);
                 if ($v->validate()) {
                     $params['password'] = create_hash($params['password']);
                     $sql = "INSERT INTO user (";
                     foreach ($params as $key => $value) {
                         $sql .= $key . ",";
                     }
                     $sql = substr($sql, 0, -1);
                     $sql .= ") VALUES (";
                     foreach ($params as $key => $value) {
                         $sql .= " :" . $key . ",";
                         $params[':' . $key] = $value;
                     }
                     $sql = substr($sql, 0, -1);
                     $sql .= ")";
                     $query = $this->db->prepare($sql);
                     $query->execute($params);
                     $user_id = $this->get_user_id($params['username']);
                     $auth = new Token($this->db);
                     require_once 'core/Mail.php';
                     $mail = new Mail();
                     $mail->addAddress($params['email'], $params['username']);
                     $mail->isHTML(true);
                     $mail->Subject = "Welcome to buckbrowser";
                     $mail->Body = str_replace(['%username%', '%bb-link%'], [$params['username'], 'http://buckbrowser.langstra.nl'], file_get_contents(TEMPLATE_PATH . 'mail/signup.html'));
                     $mail->send();
                     return array('token' => $auth->create_token($user_id));
                 } else {
                     $return_errors['incorrect_fields'] = 'username';
                 }
             } else {
                 $return_errors['incorrect_fields'] = 'email';
             }
         } else {
             $return_errors['already_exists'] = $used_values;
         }
     } else {
         $return_errors['empty_fields'] = array_keys($v->errors());
     }
     return $this->create_error($return_errors);
 }

 private function getRandomToken($studentId)
 {
     $t = new Token($this->tokenAlphabet, $this->tokenLength);
     // check for existing tokens
     while ($this->checkToken($studentId, $t->getString())) {
         $t = Token($this->tokenAlphabet, $this->tokenLength);
     }
     return $t->getString();
 }

 public function getSalt()
 {
     $password = $this->password;
     $token = new Token();
     $hash = $token->generatePassword(15);
     $this->hash = $hash;
     $salt = md5($password . $hash);
     return $salt;
 }

 function apply(TokenStream $ts, Token $t, BlueContext $blueContext)
 {
     if (isset($this->raytraceLiteral[(string) $t]) || isset($this->raytraceNonliteral[$t->type()])) {
         foreach ($this->directives as $directives) {
             foreach ($directives as $directive) {
                 $directive->apply($ts, $this, $blueContext);
             }
         }
     }
 }

 /**
  * Check if the token is operator
  *
  * @param Token $token
  * @return boolean
  */
 public function isOperator(Token $token)
 {
     if (T_STRING == $token->getType()) {
         if (isset($this->byPass[$token->getValue()])) {
             return false;
         }
         return isset($this->operatorsStrings[$token->getValue()]);
     }
     return isset($this->operators[$token->getType()]);
 }

 /**
  * Adds a new token to the admin, and returns with the id of the newly created Doctrine model.
  *
  * @param object $admin an Admin model object
  * @param string $tokenType
  * @param string $token default null if null then one will be generated
  * @param string $rid default null if null then one will be generated
  * @return object the new Token model object
  */
 public static function addToken($admin, $tokenType, $token = null, $rid = null)
 {
     $model = new Token();
     $model->username = $admin['username'];
     $model->type = $tokenType;
     $model->token = $token === null ? self::createRandomString() : $token;
     $model->rid = $rid === null ? self::createRandomString(32) : $rid;
     $model->save();
     return $model;
 }