/// <summary>Get the access-token by username and password</summary>
/// <param name="parameters"></param>
/// <param name="_repo"></param>
/// <param name="_settings"></param>
public ResponseData DoPassword(Parameters parameters, IRTokenRepository _repo, IOptions <Audience> _settings)
{
var refresh_token = Guid.NewGuid().ToString().Replace("-", "");
var rToken = new RToken
{
ClientId = parameters.username,
RefreshToken = refresh_token,
Id = Guid.NewGuid().ToString(),
IsStop = 0
};
if (_repo.AddToken(rToken).Result)
{
dynamic UserInfo = new System.Dynamic.ExpandoObject();
UserInfo.FirstName = parameters.fullname;
UserInfo.UserName = parameters.username;
return(new ResponseData
{
Code = "999",
Message = "OK",
Content = UserInfo,
Data = GetJwt(parameters.username, refresh_token, _settings)
});
}
else
{
return(new ResponseData
{
Code = "909",
Message = "can not add token to database",
Data = null
});
}
}
/// <summary>
/// get the access-token by username and password
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
private ResponseData GenerateJwt(Parameters parameters)
{
var refresh_token = Guid.NewGuid().ToString().Replace("-", "");
var rToken = new RToken
{
ClientName = parameters.username,
RefreshToken = refresh_token,
Id = Guid.NewGuid().ToString(),
IsStop = 0
};
//store the refresh_token
if (_tokenRepository.AddToken(rToken))
{
return(new ResponseData
{
Code = "999",
Message = "Ok",
Data = GetJwt(parameters.username.Trim(), refresh_token)
});
}
return(new ResponseData
{
Code = "909",
Message = "can not add token to database",
Data = null
});
}
public ResponseModel <Office365Model> GenerateToken(string email)
{
var refresh_token = Guid.NewGuid().ToString().Replace("-", "");
var rToken = new RToken
{
Email = email,
RefreshToken = refresh_token,
Id = Guid.NewGuid().ToString(),
IsStop = 0
};
//store the refresh_token
if (RToken.AddToken(rToken))
{
return(new ResponseModel <Office365Model>
{
status = true,
message = "OK",
Data = GetJwt(email, refresh_token)
});
}
else
{
return(new ResponseModel <Office365Model>
{
status = false,
message = "can not add token to database",
Data = null
});
}
}
public override bool Parse(ParseContext context, IAstNode parent)
{
RToken currentToken = context.Tokens.CurrentToken;
string text = context.TextProvider.GetText(currentToken);
double result;
Debug.Assert(currentToken.TokenType == RTokenType.Number ||
currentToken.TokenType == RTokenType.Infinity ||
currentToken.TokenType == RTokenType.NaN);
if (currentToken.TokenType == RTokenType.Infinity)
{
Value = new RNumber(Double.PositiveInfinity);
}
else if (currentToken.TokenType == RTokenType.NaN)
{
Value = new RNumber(Double.NaN);
}
else
{
// If parsing fails we still need to create node
// since we need a range to squiggle
result = Double.NaN;
if (!Number.TryParse(text, out result))
{
// Something unparsable
context.AddError(new ParseError(ParseErrorType.NumberExpected, ErrorLocation.Token, currentToken));
}
Value = new RNumber(result);
}
return(base.Parse(context, parent));
}
public override bool Parse(ParseContext context, IAstNode parent)
{
RToken currentToken = context.Tokens.CurrentToken;
string text = context.TextProvider.GetText(currentToken);
bool? result = null;
Debug.Assert(currentToken.TokenType == RTokenType.Logical);
if (text.Equals("TRUE", StringComparison.Ordinal) || text.Equals("T", StringComparison.Ordinal))
{
result = true;
}
else if (text.Equals("FALSE", StringComparison.Ordinal) || text.Equals("F", StringComparison.Ordinal))
{
result = false;
}
if (result.HasValue)
{
Value = new RLogical(result.Value);
return(base.Parse(context, parent));
}
context.AddError(new ParseError(ParseErrorType.LogicalExpected, ErrorLocation.Token, currentToken));
return(false);
}
private void CalculateVirtualEnd(ParseContext context)
{
int position = this.Arguments.Count > 0 ? this.Arguments.End : this.OpenBrace.End;
if (!context.Tokens.IsEndOfStream())
{
TokenStream <RToken> tokens = context.Tokens;
// Walk through tokens allowing numbers, identifiers and operators
// as part of the function signature. Stop at keywords (except 'if'),
// or curly braces.
int i = tokens.Position;
_virtualEnd = 0;
for (; i < tokens.Length; i++)
{
RToken token = tokens[i];
if (token.TokenType == RTokenType.Keyword || RParser.IsListTerminator(context, RTokenType.OpenBrace, token))
{
_virtualEnd = token.Start;
break;
}
}
}
if (_virtualEnd == 0)
{
_virtualEnd = context.TextProvider.Length;
}
}
public override bool Parse(ParseContext context, IAstNode parent)
{
RToken currentToken = context.Tokens.CurrentToken;
string text = context.TextProvider.GetText(currentToken);
double realPart = 0;
double imaginaryPart = 0;
Debug.Assert(currentToken.TokenType == RTokenType.Complex);
// Split into real and imaginary parts. Imaginary part
// should always be there since otherwise tokenizer would
// not have idenfified the number as complex. Note that
// real part may be missing as in '+0i'. Operator may also
// be missing: 1i is a legal complex number.
Debug.Assert(text[text.Length - 1] == 'i');
// Drop trailing i and retokenize as two numbers
RTokenizer tokenizer = new RTokenizer(separateComments: false);
IReadOnlyTextRangeCollection <RToken> tokens = tokenizer.Tokenize(text.Substring(0, text.Length - 1));
if (tokens.Count == 1)
{
// Only imaginary part is present
Debug.Assert(tokens[0].TokenType == RTokenType.Number);
// TODO: handle complex numbers in Hex
if (!Double.TryParse(text.Substring(tokens[0].Start, tokens[0].Length), out imaginaryPart))
{
imaginaryPart = 0;
}
}
else if (tokens.Count == 3)
{
// Real and imaginary parts present
Debug.Assert(tokens[0].TokenType == RTokenType.Number);
Debug.Assert(tokens[1].TokenType == RTokenType.Operator);
Debug.Assert(tokens[2].TokenType == RTokenType.Number);
// TODO: handle complex numbers in Hex
if (!Double.TryParse(text.Substring(tokens[0].Start, tokens[0].Length), out realPart))
{
realPart = 0;
}
if (!Double.TryParse(text.Substring(tokens[2].Start, tokens[2].Length), out imaginaryPart))
{
imaginaryPart = 0;
}
}
else
{
context.AddError(new MissingItemParseError(ParseErrorType.NumberExpected, context.Tokens.PreviousToken));
return(false);
}
Complex complex = new Complex(realPart, imaginaryPart);
NodeValue = new RComplex(complex);
return(base.Parse(context, parent));
}
private RToken TryPopMatchingBrace(RToken token)
{
if (_openBraces.Peek().TokenType == GetMatchingBraceToken(token.TokenType))
{
return(_openBraces.Pop());
}
return(null);
}
public override bool Parse(ParseContext context, IAstNode parent) {
RToken currentToken = context.Tokens.CurrentToken;
this.Token = currentToken;
context.Tokens.MoveToNextToken();
return base.Parse(context, parent);
}
private static TextChangeType CheckChangeInsideComment(TextChangeContext context)
{
var comments = context.EditorTree.AstRoot.Comments;
IReadOnlyList <int> affectedComments = comments.GetItemsContainingInclusiveEnd(context.NewStart);
if (affectedComments.Count == 0)
{
return(TextChangeType.Trivial);
}
if (affectedComments.Count > 1)
{
return(TextChangeType.Structure);
}
// Make sure user is not deleting leading # effectively
// destroying the comment
RToken comment = comments[affectedComments[0]];
if (comment.Start == context.NewStart && context.OldLength > 0)
{
return(TextChangeType.Structure);
}
// The collection will return a match if the comment starts
// at the requested location. However, the change is not
// inside the comment if it's at the comment start and
// the old length of the change is zero.
if (comment.Start == context.NewStart && context.OldLength == 0)
{
if (context.NewText.IndexOf('#') < 0)
{
context.ChangedComment = comment;
return(TextChangeType.Comment);
}
}
if (context.NewText.IndexOfAny(CharExtensions.LineBreakChars) >= 0)
{
return(TextChangeType.Structure);
}
// The change is not safe if old or new text contains line breaks
// as in R comments runs to the end of the line and deleting
// line break at the end of the comment may bring code into
// the comment range and change the entire file structure.
if (context.OldText.IndexOfAny(CharExtensions.LineBreakChars) >= 0)
{
return(TextChangeType.Structure);
}
context.ChangedComment = comment;
return(TextChangeType.Comment);
}
public override bool Parse(ParseContext context, IAstNode parent)
{
RToken currentToken = context.Tokens.CurrentToken;
this.Token = currentToken;
context.Tokens.MoveToNextToken();
return(base.Parse(context, parent));
}
public ResponseModel <Office365Model> DoRefreshToken(JWModel parameters)
{
var token = RToken.GetToken(parameters.RefreshToken, parameters.Email);
if (token == null)
{
return(new ResponseModel <Office365Model>
{
status = false,
message = "can not refresh token",
Data = null
});
}
if (token.IsStop == 1)
{
return(new ResponseModel <Office365Model>
{
status = false,
message = "refresh token has expired",
Data = null
});
}
var refresh_token = Guid.NewGuid().ToString().Replace("-", "");
token.IsStop = 1;
//expire the old refresh_token and add a new refresh_token
var updateFlag = RToken.ExpireToken(token);
var addFlag = RToken.AddToken(new RToken
{
Email = parameters.Email,
RefreshToken = refresh_token,
Id = Guid.NewGuid().ToString(),
IsStop = 0
});
if (updateFlag && addFlag)
{
return(new ResponseModel <Office365Model>
{
status = true,
message = "OK",
Data = GetJwt(parameters.Email, refresh_token)
});
}
else
{
return(new ResponseModel <Office365Model>
{
status = false,
message = "can not expire token or a new token",
Data = null
});
}
}
/// <summary>
/// Propagates keyword association to the target token.
/// <seealso cref="AssociateKeywordPositionWithOpenBrace"/>
/// </summary>
private void AssociateKeywordPositionWithToken(RToken source, RToken target)
{
int keywordPosition;
if (_bracetoKeywordPositionMap.TryGetValue(source, out keywordPosition))
{
_bracetoKeywordPositionMap[target] = keywordPosition;
}
}
public bool ExpireToken(RToken token)
{
using (var db = new TokenDbContext())
{
db.RTokens.Update(token);
return(db.SaveChanges() > 0);
}
}
public bool AddToken(RToken token)
{
using (var db = new TokenDbContext())
{
db.RTokens.Add(token);
return(db.SaveChanges() > 0);
}
}
internal static bool IsPackageListCompletion(ITextBuffer textBuffer, int position)
{
ITextSnapshot snapshot = textBuffer.CurrentSnapshot;
ITextSnapshotLine line = snapshot.GetLineFromPosition(position);
string lineText = line.GetText();
int linePosition = position - line.Start;
// We should be either at library(| or inside library(|)
// or over package name like in library(ba|se)
// Go left and right looking for
RTokenizer tokenizer = new RTokenizer();
ITextProvider textProvider = new TextStream(lineText);
IReadOnlyTextRangeCollection <RToken> c = tokenizer.Tokenize(textProvider, 0, textProvider.Length);
TokenStream <RToken> tokens = new TokenStream <RToken>(c, RToken.EndOfStreamToken);
while (!tokens.IsEndOfStream())
{
if (tokens.CurrentToken.Start >= linePosition)
{
break;
}
if (tokens.CurrentToken.TokenType == RTokenType.Identifier)
{
string identifier = textProvider.GetText(tokens.CurrentToken);
if (identifier == "library" || identifier == "require")
{
tokens.MoveToNextToken();
if (tokens.CurrentToken.TokenType == RTokenType.OpenBrace)
{
RToken openBrace = tokens.CurrentToken;
while (!tokens.IsEndOfStream())
{
if (tokens.CurrentToken.TokenType == RTokenType.CloseBrace)
{
if (linePosition >= openBrace.End && linePosition <= tokens.CurrentToken.Start)
{
return(true);
}
return(false);
}
else if (tokens.NextToken.TokenType == RTokenType.EndOfStream)
{
return(true);
}
tokens.MoveToNextToken();
}
}
}
}
tokens.MoveToNextToken();
}
return(false);
}
/// <summary>Expire token</summary>
/// <param name="token"></param>
public async Task <bool> ExpireToken(RToken token)
{
var filter = Builders <RToken> .Filter.Eq("client_id", token.ClientId) & Builders <RToken> .Filter.Eq("refresh_token", token.RefreshToken);;
var update = Builders <RToken> .Update.Set("isstop", token.IsStop);
var collection = _db.GetCollection <RToken>("RToken");
var result = await collection.UpdateOneAsync(filter, update);
return(result.ModifiedCount > 0);
}
public override bool Parse(ParseContext context, IAstNode parent)
{
RToken currentToken = context.Tokens.CurrentToken;
string text = context.TextProvider.GetText(currentToken);
Debug.Assert(currentToken.TokenType == RTokenType.String);
Value = new RString(text);
return(base.Parse(context, parent));
}
public IActionResult DeleteToken()
{
var ident = User.Identity as ClaimsIdentity;
var userID = ident.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier)?.Value;
AppUser user = _userManager.Users.SingleOrDefault(r => r.Id == userID);
RToken rToken = (RToken)this._repo;
rToken.DeleteByUserId(user.Id);
return(Ok());
}
/// <summary>
/// Given opening curly brace tries to find keyword that is associated
/// with the scope and calculate indentation based on the keyword line.
/// </summary>
public int GetOpenCurlyBraceIndentSize(RToken openCurlyBraceToken, TextBuilder tb, RFormatOptions options)
{
Debug.Assert(openCurlyBraceToken.TokenType == RTokenType.OpenCurlyBrace);
int keywordPosition = -1;
if (_bracetoKeywordPositionMap.TryGetValue(openCurlyBraceToken, out keywordPosition))
{
return(IndentBuilder.GetLineIndentSize(tb, keywordPosition, options.TabSize));
}
return(0);
}
private string GetClassificationName(RToken t)
{
switch (t.TokenType)
{
case RTokenType.Keyword:
return(RoxygenClassificationDefinitions.RoxygenKeywordClassificationFormatName);
case RTokenType.Identifier:
return(RoxygenClassificationDefinitions.RoxygenExportClassificationFormatName);
}
return(string.Empty);
}
/// <summary>
/// Given closing curly brace tries to find keyword that is associated
/// with the scope and calculate indentation based on the keyword line.
/// </summary>
public int GetCloseCurlyBraceIndentSize(RToken closeCurlyBraceToken, TextBuilder tb, RFormatOptions options)
{
Debug.Assert(closeCurlyBraceToken.TokenType == RTokenType.CloseCurlyBrace);
// Search stack for the first matching brace. Stack enumerates from the top down.
var openCurlyBraceToken = _openBraces.FirstOrDefault(t => t.TokenType == RTokenType.OpenCurlyBrace);
if (openCurlyBraceToken != null)
{
return(GetOpenCurlyBraceIndentSize(openCurlyBraceToken, tb, options));
}
return(0);
}
public override bool Parse(ParseContext context, IAstNode parent = null)
{
RToken currentToken = context.Tokens.CurrentToken;
Debug.Assert(currentToken.IsVariableKind());
// Not calling base since expression parser will decide
// what parent node the variable belongs to.
Token = currentToken;
context.Tokens.MoveToNextToken();
return(true);
}
private bool IsClosingToken(RToken token, AstRoot ast = null)
{
switch (token.TokenType)
{
case RTokenType.Comma:
case RTokenType.CloseBrace:
case RTokenType.CloseSquareBracket:
case RTokenType.CloseDoubleSquareBracket:
case RTokenType.Semicolon:
return(true);
}
return(false);
}
/// <summary>Add token</summary>
/// <param name="token"></param>
public async Task <bool> AddToken(RToken token)
{
var collection = _db.GetCollection <RToken>("RToken");
try
{
await collection.InsertOneAsync(token);
return(true);
}
catch
{
return(false);
}
}
private static ITextRange GetLocationRange(IAstNode node, RToken token, ErrorLocation location)
{
ITextRange itemRange = node != null ? node : token as ITextRange;
//switch (location)
//{
// case ErrorLocation.BeforeToken:
// return new TextRange(Math.Max(0, itemRange.Start-1), 1);
// case ErrorLocation.AfterToken:
// return new TextRange(itemRange.End, 1);
//}
return itemRange;
}
private static ITextRange GetLocationRange(IAstNode node, RToken token, ErrorLocation location)
{
ITextRange itemRange = node != null ? node : token as ITextRange;
//switch (location)
//{
// case ErrorLocation.BeforeToken:
// return new TextRange(Math.Max(0, itemRange.Start-1), 1);
// case ErrorLocation.AfterToken:
// return new TextRange(itemRange.End, 1);
//}
return(itemRange);
}
//scenario 1 ： get the access-token by username and password
private ResponseData DoPassword(Parameters parameters)
{
//validate the client_id/client_secret/username/password
var isValidated = UserInfo.GetAllUsers().Any(x => x.ClientId == parameters.client_id &&
x.ClientSecret == parameters.client_secret &&
x.UserName == parameters.username &&
x.Password == parameters.password);
if (!isValidated)
{
return(new ResponseData
{
Code = "902",
Message = "invalid user infomation",
Data = null
});
}
var refresh_token = Guid.NewGuid().ToString().Replace("-", "");
var rToken = new RToken
{
ClientId = parameters.client_id,
RefreshToken = refresh_token,
Id = Guid.NewGuid().ToString(),
IsStop = 0
};
//store the refresh_token
if (_repo.AddToken(rToken))
{
return(new ResponseData
{
Code = "999",
Message = "OK",
Data = GetJwt(parameters.client_id, refresh_token)
});
}
else
{
return(new ResponseData
{
Code = "909",
Message = "can not add token to database",
Data = null
});
}
}
/// <summary>Get the access-token by username and password</summary>
/// <param name="parameters"></param>
/// <param name="_repo"></param>
/// <param name="_settings"></param>
public ResponseData DoPassword(Parameters parameters, IRTokenRepository _repo, IOptions <Audience> _settings)
{
try
{
var refresh_token = Guid.NewGuid().ToString().Replace("-", "");
var rToken = new RToken
{
ClientId = parameters.username,
RefreshToken = refresh_token,
Id = Guid.NewGuid().ToString(),
IsStop = 0
};
if (_repo.AddToken(rToken).Result)
{
dynamic UserInfo = new System.Dynamic.ExpandoObject();
UserInfo.FirstName = parameters.fullname;
UserInfo.UserName = parameters.username;
return(new ResponseData
{
Code = "999",
Message = "OK",
Content = UserInfo,
Data = GetJwt(parameters.username, refresh_token, _settings, BsonSerializer.Deserialize <RegisterModel>(MongoHelper.CheckForDatas("UserName", parameters.username, null, null, "Authentication", "Authentication")).UserRole)
});
}
else
{
return(new ResponseData
{
Code = "909",
Message = "can not add token to database",
Data = null
});
}
}
catch (Exception ex)
{
LoggerDataAccess.CreateLog("AuthHelper", "DoPassword", ex.Message);
return(new ResponseData
{
Code = "400",
Message = "Failed",
Data = null
});
}
}
private int TryFindNextArgument(ParseContext context, int startPosition)
{
for (int i = startPosition; i < context.Tokens.Length; i++)
{
RToken token = context.Tokens[i];
if (token.TokenType == RTokenType.Comma || token.TokenType == RTokenType.CloseBrace)
{
return(i);
}
if (RParser.IsListTerminator(context, RTokenType.OpenBrace, token))
{
break;
}
}
return(-1);
}
private static bool IsVariableNameToken(string lineText, RToken token)
{
if (token.TokenType == RTokenType.Identifier)
{
return(true);
}
if (token.TokenType == RTokenType.Operator)
{
if (token.Length == 1)
{
return(lineText[token.Start] == '$' || lineText[token.Start] == '@');
}
else if (token.Length == 2)
{
return(lineText[token.Start] == ':' && lineText[token.Start + 1] == ':');
}
}
return(false);
}
public IActionResult Refresh(RToken refresh)
{
var refreshedToken = tokenService.RefreshTokinValidation(refresh.Refresh);
if (refreshedToken == null)
{
return(BadRequest("invalid_grant"));
}
User user = _context.Users.Find(refreshedToken.UserId);
return(Ok(new
{
access_token = new JwtSecurityTokenHandler().WriteToken(tokenService.GenerateAccessToken(user)),
refresh_token = refreshedToken.Token,
user_id = user.Id,
user_email = user.FirstName
}));
}
public MissingItemParseError(ParseErrorType errorType, RToken token) :
base(errorType, ErrorLocation.AfterToken, token) {
}
/// <summary>
/// Propagates keyword association to the target token.
/// <seealso cref="AssociateKeywordPositionWithOpenBrace"/>
/// </summary>
private void AssociateKeywordPositionWithToken(RToken source, RToken target) {
int keywordPosition;
if (_bracetoKeywordPositionMap.TryGetValue(source, out keywordPosition)) {
_bracetoKeywordPositionMap[target] = keywordPosition;
}
}
private RToken TryPopMatchingBrace(RToken token) {
if (_openBraces.Peek().TokenType == GetMatchingBraceToken(token.TokenType)) {
return _openBraces.Pop();
}
return null;
}
private static bool IsVariableNameToken(string lineText, RToken token) {
if (token.TokenType == RTokenType.Identifier) {
return true;
}
if (token.TokenType == RTokenType.Operator) {
if (token.Length == 1) {
return lineText[token.Start] == '$' || lineText[token.Start] == '@';
} else if (token.Length == 2) {
return lineText[token.Start] == ':' && lineText[token.Start + 1] == ':';
}
}
return false;
}
/// <summary>
/// Given closing curly brace tries to find keyword that is associated
/// with the scope and calculate indentation based on the keyword line.
/// </summary>
public int GetCloseCurlyBraceIndentSize(RToken closeCurlyBraceToken, TextBuilder tb, RFormatOptions options) {
Debug.Assert(closeCurlyBraceToken.TokenType == RTokenType.CloseCurlyBrace);
// Search stack for the first matching brace. Stack enumerates from the top down.
var openCurlyBraceToken = _openBraces.FirstOrDefault(t => t.TokenType == RTokenType.OpenCurlyBrace);
if (openCurlyBraceToken != null) {
return GetOpenCurlyBraceIndentSize(openCurlyBraceToken, tb, options);
}
return 0;
}
internal TokenNode(RToken token) {
Token = token;
}
public static bool IsListTerminator(ParseContext context, RTokenType openingTokenType, RToken token) {
RTokenType tokenType = token.TokenType;
if (tokenType == RTokenType.CloseCurlyBrace ||
tokenType == RTokenType.Semicolon) {
return true;
}
switch (openingTokenType) {
case RTokenType.OpenBrace:
if (tokenType == RTokenType.CloseSquareBracket || tokenType == RTokenType.CloseDoubleSquareBracket) {
return true;
}
break;
case RTokenType.OpenSquareBracket:
if (tokenType == RTokenType.CloseBrace || tokenType == RTokenType.CloseDoubleSquareBracket) {
return true;
}
break;
case RTokenType.OpenDoubleSquareBracket:
if (tokenType == RTokenType.CloseBrace || tokenType == RTokenType.CloseSquareBracket) {
return true;
}
break;
}
if (tokenType == RTokenType.Operator && token.IsKeywordText(context.TextProvider, "<-")) {
return true;
}
if (tokenType == RTokenType.Keyword &&
!token.IsKeywordText(context.TextProvider, "if") &&
!token.IsKeywordText(context.TextProvider, "function")) {
return true;
}
return false;
}
/// <summary>
/// Associates keyword with the open brace. Used when formatter needs to determine
/// indentation level of the new formatting scope when it encounters { token.
/// </summary>
/// <remarks>
/// Closing curly indentation is defined by the line that either holds the opening curly brace
/// or the line that holds keyword that defines the expression that the curly belongs to.
/// Examples:
///
/// x <-
/// function(a) {
/// }
///
/// x <- function(a) {
/// }
///
/// First keyword is associated with the open brace, then, when brace pair closes, association
/// is propagated to the closing brace and then to the opening curly. When curly pair closes
/// formatter then finds appropriate indentation based on the line that contains the keyword token.
/// </remarks>
private void AssociateKeywordPositionWithOpenBrace(RToken openBrace, int keywordPosition) {
_bracetoKeywordPositionMap[openBrace] = keywordPosition;
}
/// <summary>
/// Given opening curly brace tries to find keyword that is associated
/// with the scope and calculate indentation based on the keyword line.
/// </summary>
public int GetOpenCurlyBraceIndentSize(RToken openCurlyBraceToken, TextBuilder tb, RFormatOptions options) {
Debug.Assert(openCurlyBraceToken.TokenType == RTokenType.OpenCurlyBrace);
int keywordPosition = -1;
if (_bracetoKeywordPositionMap.TryGetValue(openCurlyBraceToken, out keywordPosition)) {
return IndentBuilder.GetLineIndentSize(tb, keywordPosition, options.TabSize);
}
return 0;
}
private bool IsClosingToken(RToken token, AstRoot ast = null) {
switch (token.TokenType) {
case RTokenType.Comma:
case RTokenType.CloseBrace:
case RTokenType.CloseSquareBracket:
case RTokenType.CloseDoubleSquareBracket:
case RTokenType.Semicolon:
return true;
}
return false;
}
