public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsSelectorTerminator(stream.Current.Type))
{
var selector = itemFactory.CreateSpecific<SelectorGroup>(this, text, stream);
if (!selector.Parse(itemFactory, text, stream))
break;
_Selectors.Add(selector);
Children.Add(selector);
if (stream.Current.Type == TokenType.Comma)
Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var block = itemFactory.CreateSpecific<RuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Block = block;
Children.Add(block);
}
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "extend"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
var selector = itemFactory.CreateSpecific<SelectorGroup>(this, text, stream);
if (selector.Parse(itemFactory, text, stream))
{
Selector = selector;
Children.Add(selector);
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new OptionalModifier();
if (modifier.Parse(itemFactory, text, stream))
{
Modifier = modifier;
Children.Add(modifier);
}
}
if (stream.Current.Type == TokenType.Semicolon)
Semicolon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
return Children.Count > 0;
}
/// <summary>
/// Determines if element is a self-closing element (i.e. like <br />
/// </summary>
/// <param name="textProvider">Text provider</param>
/// <param name="prefixRange">Text range of the element prefix</param>
/// <param name="nameRange">Text range of the element name</param>
/// <returns>True if element is a self-closing element.</returns>
public bool IsSelfClosing(ITextProvider textProvider, ITextRange prefixRange, ITextRange nameRange) {
if (nameRange.Length == 0)
return false;
string name = textProvider.GetText(nameRange);
if (name[0] == '!')
return true; // bang tags are always self-closing
if (prefixRange.Length == 0)
return _defaultProvider.IsSelfClosing(textProvider, nameRange);
string prefix = textProvider.GetText(prefixRange);
IHtmlClosureProvider provider; ;
_providers.TryGetValue(prefix, out provider);
var textRangeProvider = provider as IHtmlClosureProviderTextRange;
if (textRangeProvider != null)
return textRangeProvider.IsSelfClosing(textProvider, nameRange);
if (provider != null)
return provider.IsSelfClosing(name);
return false;
}
protected virtual bool ParseCombinator(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
SelectorCombinator combinator = null;
switch (stream.Current.Type)
{
case TokenType.GreaterThan:
combinator = new ChildCombinator();
break;
case TokenType.Plus:
combinator = new AdjacentSiblingCombinator();
break;
case TokenType.Tilde:
combinator = new GeneralSiblingCombinator();
break;
}
if (combinator != null)
{
if (combinator.Parse(itemFactory, text, stream))
{
Children.Add(combinator);
Combinator = combinator;
}
}
else if (stream.Current.Type != TokenType.OpenCurlyBrace)
{
// whitespace only combinator means no adding to children or parsing
// we just want to know that there was a combinator
if (stream.Current.Start >= (stream.Peek(-1).End + 1))
Combinator = new DescendantCombinator();
}
return Combinator != null;
}
public static string ResolvePath(StringValue item, ITextProvider text, DirectoryInfo currentDirectory)
{
var relativePath = text.GetText(item.Start, item.Length).Trim('\'', '"');
var segments = relativePath.Split('/');
if (segments.Length == 0)
return null;
var path = currentDirectory.FullName;
for (int i = 0; i < (segments.Length - 1); i++)
path = Path.Combine(path, segments[i]);
var directory = new DirectoryInfo(Path.GetFullPath(path));
if (!directory.Exists)
return null;
var filename = segments[segments.Length - 1];
if (string.IsNullOrEmpty(Path.GetExtension(filename)))
filename += ".scss";
var files = directory.GetFiles("*" + filename);
var comparer = StringComparer.OrdinalIgnoreCase;
return files.Where(x => comparer.Equals(x.Name, filename) || comparer.Equals(x.Name, "_" + filename))
.Select(x => x.FullName)
.FirstOrDefault();
}
public virtual void Clear() {
OldRange = TextRange.EmptyRange;
NewRange = TextRange.EmptyRange;
OldText = null;
NewText = null;
}
public TextChange(TextChange change, ITextProvider oldText, ITextProvider newText)
: this() {
this.Combine(change);
OldText = oldText;
NewText = newText;
}
public TextChange(int start, int oldLength, int newLength, ITextProvider oldText, ITextProvider newText)
: this() {
this.Combine(new TextChange(start, oldLength, newLength));
OldText = oldText;
NewText = newText;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier && IsModifier(text.GetText(stream.Current.Start, stream.Current.Length)))
Modifier = Children.AddCurrentAndAdvance(stream);
ParseItem mediaType;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out mediaType))
{
MediaType = mediaType;
Children.Add(mediaType);
}
while (!IsTerminator(text, stream))
{
var expression = itemFactory.CreateSpecific<MediaQueryExpression>(this, text, stream);
if (expression.Parse(itemFactory, text, stream))
{
_Expressions.Add(expression);
Children.Add(expression);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (stream.Current.Type == TokenType.Comma)
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
return Children.Count > 0;
}
/// <summary>
/// Determines number of line breaks before position
/// </summary>
public static int LineBreaksBeforePosition(ITextProvider textProvider, int position) {
int count = 0;
if (position > 0) {
for (int i = position - 1; i >= 0; i--) {
char ch = textProvider[i];
if (!Char.IsWhiteSpace(ch))
return count;
if (ch == '\r') {
if (i > 0 && textProvider[i - 1] == '\n') {
i--;
}
count++;
} else if (ch == '\n') {
if (i > 0 && textProvider[i - 1] == '\r') {
i--;
}
count++;
}
}
}
return count;
}
private ParseItemList Parse(ITextProvider text, IItemFactory itemFactory, ITokenStream stream, IParsingExecutionContext context)
{
var results = new ParseItemList();
while (!context.IsCancellationRequested && stream.Current.Type != TokenType.EndOfFile)
{
int position = stream.Position;
ParseItem item;
if (!itemFactory.TryCreate(null, text, stream, out item))
break;
if (item.Parse(itemFactory, text, stream))
results.Add(item);
// guard against infinite loop (in case token couldn't be handled)
if (stream.Position == position)
stream.Advance();
}
// freeze everything
if (!context.IsCancellationRequested)
foreach (var item in results)
item.Freeze();
return results;
}
public string ResolvePath(DirectoryInfo currentDirectory, ITextProvider text)
{
if (Filename == null || Filename.Length == 0)
return null;
return ImportResolver.ResolvePath(Filename, text, currentDirectory);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "each"))
{
ParseRule(itemFactory, text, stream);
while (!IsListTerminator(stream.Current.Type))
{
var item = itemFactory.CreateSpecific<ListItem>(this, text, stream);
if (item != null && item.Parse(itemFactory, text, stream))
{
_Items.Add(item);
Children.Add(item);
}
else
{
// bad news bears
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
}
return Children.Count > 0;
}
public HomeController()
{
//note: тут можно поменять провайдера текста
_textProvider = new HardCodedTextProvider();
//_textProvider = new LocalFileTextProivider();
}
public static bool IsValidModifier(ITextProvider text, Token token, string name)
{
if (token.Type == TokenType.Identifier)
return text.CompareOrdinal(token.Start, name);
return false;
}
private void value_TextChanged(ITextProvider sender, string oldText, string newText)
{
double celsius = 0;
double.TryParse(value.Text, out celsius);
double fahrenheit = celsius * 9 / 5 + 32;
result.Text = fahrenheit.ToString();
}
public TextChangeEventArgs(int start, int oldLength, int newLength, ITextProvider oldText, ITextProvider newText) {
Start = start;
OldLength = oldLength;
NewLength = newLength;
OldText = oldText;
NewText = newText;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier)
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.ElementName);
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (ParseSelectorToken(itemFactory, text, stream))
ParseCombinator(itemFactory, text, stream);
return Children.Count > 0;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.OpenBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.SquareBrace);
if (stream.Current.Type == TokenType.Identifier)
Attribute = Children.AddCurrentAndAdvance(stream);
if (IsAttributeOperator(stream.Current.Type))
Operator = Children.AddCurrentAndAdvance(stream);
if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
{
Value = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
if (Value != null)
Children.Add(Value);
} else if (stream.Current.Type == TokenType.Identifier)
{
Value = Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
}
if (stream.Current.Type == TokenType.CloseBrace)
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.SquareBrace);
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "media"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
while (!IsTerminator(stream.Current.Type))
{
var query = itemFactory.CreateSpecific<MediaQuery>(this, text, stream);
if (query.Parse(itemFactory, text, stream))
{
_Queries.Add(query);
Children.Add(query);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
var block = itemFactory.CreateSpecific<MediaQueryBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
return Children.Count > 0;
}
public string GetName(ITextProvider text)
{
if (IsValid)
return text.GetText(Name.Start, Name.Length);
return null;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.LessThan)
{
OpenTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
if (stream.Current.Type == TokenType.Identifier)
{
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
while (!IsTagTerminator(stream.Current.Type))
{
var attribute = itemFactory.CreateSpecific<XmlAttribute>(this, text, stream);
if (!attribute.Parse(itemFactory, text, stream))
break;
Children.Add(attribute);
_Attributes.Add(attribute);
OnAttributeParsed(attribute, text);
}
}
if (stream.Current.Type == TokenType.Slash)
CloseSlash = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
if (stream.Current.Type == TokenType.GreaterThan)
CloseTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
}
return Children.Count > 0;
}
/// <summary>
/// Determines number of line breaks after position
/// </summary>
public static int LineBreaksAfterPosition(ITextProvider textProvider, int position) {
int count = 0;
for (int i = position; i < textProvider.Length; i++) {
char ch = textProvider[i];
if (!Char.IsWhiteSpace(ch))
return count;
if (ch == '\r') {
if (i < textProvider.Length - 1 && textProvider[i + 1] == '\n') {
i++;
}
count++;
} else if (ch == '\n') {
if (i < textProvider.Length - 1 && textProvider[i + 1] == '\r') {
i++;
}
count++;
}
}
return count;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if ((IsConditionalDirective(text, stream) || IsConditionalContinuationDirective(text, stream)))
{
ParseRule(itemFactory, text, stream);
while (!IsConditionTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Children.Add(item);
ConditionStatements.Add(item);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
while (IsConditionalContinuationDirective(text, stream))
{
var subsequentConditional = itemFactory.CreateSpecific<ConditionalControlDirective>(this, text, stream);
if (!subsequentConditional.Parse(itemFactory, text, stream))
break;
ElseStatements.Add(subsequentConditional);
Children.Add(subsequentConditional);
}
}
return Children.Count > 0;
}
protected override void ParseImport(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
{
Filename = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
if (Filename != null)
Children.Add(Filename);
}
else if (UrlItem.IsUrl(text, stream.Current))
{
var url = new UrlItem();
if (url.Parse(itemFactory, text, stream))
{
Url = url;
Children.Add(url);
}
}
while (!IsTerminator(stream.Current.Type))
{
var query = new MediaQuery();
if (!query.Parse(itemFactory, text, stream))
break;
_MediaQueries.Add(query);
Children.Add(query);
}
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
Value = Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
return Children.Count > 0;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Asterisk)
Asterisk = Children.AddCurrentAndAdvance(stream);
return Children.Count > 0;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Ampersand)
Ampersand = Children.AddCurrentAndAdvance(stream, SassClassifierType.ParentReference);
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.XmlDocumentationComment)
{
Opening = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
// look for <reference
if (stream.Current.Type == TokenType.LessThan)
{
var tag = itemFactory.CreateSpecific<XmlDocumentationTag>(this, text, stream);
if (tag.Parse(itemFactory, text, stream))
{
Tag = tag;
Children.Add(tag);
}
else
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
}
}
else
{
while (!IsCommentTerminator(stream.Current.Type))
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
}
}
//if (stream.Current.Type == TokenType.NewLine)
// NewLine = Children.AddCurrentAndAdvance(stream);
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "function"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
if (stream.Current.Type == TokenType.Function)
{
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.UserFunctionDefinition);
FunctionName = text.GetText(Name.Start, Name.Length);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
while (!IsArgumentTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific <FunctionArgumentDefinition>(this, text, stream);
if (argument == null || !argument.Parse(itemFactory, text, stream))
{
break;
}
Arguments.Add(argument);
Children.Add(argument);
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
var body = new UserFunctionBody();
if (body.Parse(itemFactory, text, stream))
{
Body = body;
Children.Add(body);
}
}
return(Children.Count > 0);
}
public virtual ReadOnlyTextRangeCollection <T> Tokenize(ITextProvider textProvider, int start, int length, bool excludePartialTokens)
{
Debug.Assert(start >= 0 && length >= 0 && start + length <= textProvider.Length);
this._cs = new CharacterStream(textProvider);
this._cs.Position = start;
this.Tokens = new TextRangeCollection <T>();
while (!this._cs.IsEndOfStream())
{
// Keep on adding tokens...
AddNextToken();
if (this._cs.Position >= start + length)
{
break;
}
}
if (excludePartialTokens)
{
var end = start + length;
// Exclude tokens that are beyond the specified range
int i;
for (i = this.Tokens.Count - 1; i >= 0; i--)
{
if (this.Tokens[i].End <= end)
{
break;
}
}
i++;
if (i < this.Tokens.Count)
{
this.Tokens.RemoveRange(i, this.Tokens.Count - i);
}
}
var collection = new ReadOnlyTextRangeCollection <T>(this.Tokens);
this.Tokens = null;
return(collection);
}
/// <summary>
/// Incrementally applies whitespace change to the buffer
/// having old and new tokens produced from the 'before formatting'
/// and 'after formatting' versions of the same text.
/// </summary>
/// <param name="editorBuffer">Text buffer to apply changes to</param>
/// <param name="oldTextProvider">Text provider of the text fragment before formatting</param>
/// <param name="newTextProvider">Text provider of the formatted text</param>
/// <param name="oldTokens">Tokens from the 'before' text fragment</param>
/// <param name="newTokens">Tokens from the 'after' text fragment</param>
/// <param name="formatRange">Range that is being formatted in the text buffer</param>
/// <param name="transactionName">Name of the undo transaction to open</param>
/// <param name="selectionTracker">
/// Selection tracker object that will save,
/// track and restore selection after changes have been applied.</param>
/// <param name="additionalAction">
/// Action to perform after changes are applies by undo unit is not yet closed.
/// </param>
public void ApplyChange(
IEditorBuffer editorBuffer,
ITextProvider oldTextProvider,
ITextProvider newTextProvider,
IReadOnlyList <ITextRange> oldTokens,
IReadOnlyList <ITextRange> newTokens,
ITextRange formatRange,
string transactionName,
ISelectionTracker selectionTracker,
Action additionalAction = null)
{
Debug.Assert(oldTokens.Count == newTokens.Count);
if (oldTokens.Count == newTokens.Count)
{
using (CreateSelectionUndo(selectionTracker, _services, transactionName)) {
var textBuffer = editorBuffer.As <ITextBuffer>();
using (var edit = textBuffer.CreateEdit()) {
if (oldTokens.Count > 0)
{
// Replace whitespace between tokens in reverse so relative positions match
var oldEnd = oldTextProvider.Length;
var newEnd = newTextProvider.Length;
string newText;
for (var i = newTokens.Count - 1; i >= 0; i--)
{
var oldText = oldTextProvider.GetText(TextRange.FromBounds(oldTokens[i].End, oldEnd));
newText = newTextProvider.GetText(TextRange.FromBounds(newTokens[i].End, newEnd));
if (oldText != newText)
{
edit.Replace(formatRange.Start + oldTokens[i].End, oldEnd - oldTokens[i].End, newText);
}
oldEnd = oldTokens[i].Start;
newEnd = newTokens[i].Start;
}
newText = newTextProvider.GetText(TextRange.FromBounds(0, newEnd));
edit.Replace(formatRange.Start, oldEnd, newText);
}
else
{
var newText = newTextProvider.GetText(TextRange.FromBounds(0, newTextProvider.Length));
edit.Replace(formatRange.Start, formatRange.Length, newText);
}
edit.Apply();
additionalAction?.Invoke();
}
}
}
}
/// <summary>
/// Gets the HTML for a single sense, not including enclosing paragraph etc., only inline markup.
/// </summary>
/// <param name="tprov">Text provider if meta-labels (e.g. "Classifier") are to be included. If null, they are stripped.</param>
private static string getSenseHtmlPure(ITextProvider tprov, CedictSense sense, SearchScript script)
{
StringBuilder sb = new StringBuilder();
string strDomain = HybridToHtml(sense.Domain, script);
string strEquiv = HybridToHtml(sense.Equiv, script);
string strNote = HybridToHtml(sense.Note, script);
if (sense.Domain != HybridText.Empty)
{
if (sense.Domain.EqualsPlainText("CL:"))
{
if (tprov != null)
{
sb.Append(templateItalicsOpen);
sb.Append(escape(tprov.GetString("ResultCtrlClassifier")) + " ");
sb.Append(templateItalicsClose);
}
}
else
{
sb.Append(templateItalicsOpen);
sb.Append(strDomain);
sb.Append(templateItalicsClose);
}
}
if (sense.Domain != HybridText.Empty && !sense.Domain.EqualsPlainText("CL:"))
{
if (sense.Equiv != HybridText.Empty || sense.Note != HybridText.Empty)
{
sb.Append(' ');
}
}
sb.Append(strEquiv);
if (sense.Equiv != HybridText.Empty && sense.Note != HybridText.Empty)
{
sb.Append(' ');
}
if (sense.Note != HybridText.Empty)
{
sb.Append(templateItalicsOpen);
sb.Append(strNote);
sb.Append(templateItalicsClose);
}
// Done
return(sb.ToString());
}
/// <summary>
/// Incrementally applies whitespace change to the buffer
/// having old and new tokens produced from the 'before formatting'
/// and 'after formatting' versions of the same text.
/// </summary>
/// <param name="textBuffer">Text buffer to apply changes to</param>
/// <param name="newTextProvider">Text provider of the text fragment before formatting</param>
/// <param name="newTextProvider">Text provider of the formatted text</param>
/// <param name="oldTokens">Tokens from the 'before' text fragment</param>
/// <param name="newTokens">Tokens from the 'after' text fragment</param>
/// <param name="formatRange">Range that is being formatted in the text buffer</param>
/// <param name="transactionName">Name of the undo transaction to open</param>
/// <param name="selectionTracker">Selection tracker object that will save, track
/// <param name="additionalAction">Action to perform after changes are applies by undo unit is not yet closed.</param>
/// and restore selection after changes have been applied.</param>
public static void ApplyChangeByTokens(
ITextBuffer textBuffer,
ITextProvider oldTextProvider,
ITextProvider newTextProvider,
IReadOnlyList <ITextRange> oldTokens,
IReadOnlyList <ITextRange> newTokens,
ITextRange formatRange,
string transactionName,
ISelectionTracker selectionTracker,
Action additionalAction = null)
{
Debug.Assert(oldTokens.Count == newTokens.Count);
if (oldTokens.Count == newTokens.Count)
{
ITextSnapshot snapshot = textBuffer.CurrentSnapshot;
using (var selectionUndo = new SelectionUndo(selectionTracker, transactionName, automaticTracking: false)) {
using (ITextEdit edit = textBuffer.CreateEdit()) {
if (oldTokens.Count > 0)
{
// Replace whitespace between tokens in reverse so relative positions match
int oldEnd = oldTextProvider.Length;
int newEnd = newTextProvider.Length;
string oldText, newText;
for (int i = newTokens.Count - 1; i >= 0; i--)
{
oldText = oldTextProvider.GetText(TextRange.FromBounds(oldTokens[i].End, oldEnd));
newText = newTextProvider.GetText(TextRange.FromBounds(newTokens[i].End, newEnd));
if (oldText != newText)
{
edit.Replace(formatRange.Start + oldTokens[i].End, oldEnd - oldTokens[i].End, newText);
}
oldEnd = oldTokens[i].Start;
newEnd = newTokens[i].Start;
}
newText = newTextProvider.GetText(TextRange.FromBounds(0, newEnd));
edit.Replace(formatRange.Start, oldEnd, newText);
}
else
{
string newText = newTextProvider.GetText(TextRange.FromBounds(0, newTextProvider.Length));
edit.Replace(formatRange.Start, formatRange.Length, newText);
}
edit.Apply();
additionalAction?.Invoke();
}
}
}
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
while (true)
{
if (tokens.CurrentToken.TokenType != CssTokenType.Comma &&
tokens.CurrentToken.IsSelectorGroupTerminator())
{
break;
}
Selector selector = itemFactory.CreateSpecific <Selector>(this);
if (!selector.Parse(itemFactory, text, tokens))
{
break;
}
Selectors.Add(selector);
Children.Add(selector);
}
Selector lastSelector = (Selectors.Count > 0) ? Selectors[Selectors.Count - 1] : null;
if (tokens.CurrentToken.TokenType == CssTokenType.OpenCurlyBrace)
{
if (Children.Count == 0)
{
Children.AddParseError(ParseErrorType.SelectorBeforeRuleBlockMissing);
}
if (lastSelector != null && lastSelector.Comma != null)
{
Children.AddParseError(ParseErrorType.SelectorAfterCommaMissing);
}
RuleBlock ruleBlock = itemFactory.CreateSpecific <RuleBlock>(this);
if (ruleBlock.Parse(itemFactory, text, tokens))
{
Block = ruleBlock;
Children.Add(ruleBlock);
}
}
else if (lastSelector != null)
{
AddParseError(ParseErrorType.OpenCurlyBraceMissingForRule, ParseErrorLocation.AfterItem);
}
return(Children.Count > 0);
}
public FunctionOrConstantCommand(AutocompleteItem autocompleteItem, ITextProvider expressionTextProvider,
IScriptProvider scriptingTextProvider, IScriptProvider customFunctionsTextProvider, ISharedViewState sharedViewState, IClickedMouseButtonsProvider clickedMouseButtonsProvider, IShowFunctionDetails showFunctionDetails)
{
this._autocompleteItem = autocompleteItem;
//TODO: do we really want to show signature as text and title as tooltip?
Text = _autocompleteItem.Details.Signature;
ToolTip = _autocompleteItem.Details.Title;
_expressionTextProvider = expressionTextProvider;
_scriptingTextProvider = scriptingTextProvider;
_customFunctionsTextProvider = customFunctionsTextProvider;
_sharedViewState = sharedViewState;
_clickedMouseButtonsProvider = clickedMouseButtonsProvider;
_showFunctionDetails = showFunctionDetails;
}
protected virtual void ParseSelectorCombineOperator(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
if (IdReferenceOperator.IsAtIdReferenceOperator(tokens))
{
ParseItem combineOperator = itemFactory.Create <IdReferenceOperator>(this);
if (combineOperator.Parse(itemFactory, text, tokens))
{
SelectorCombineOperator = combineOperator;
Children.Add(combineOperator);
}
}
else
{
SelectorCombineOperator = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.SelectorCombineOperator);
}
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type != TokenType.EndOfFile)
{
var token = stream.Current;
_Start = token.Start;
_Length = token.Length;
_End = _Start + _Length;
SourceType = token.Type;
stream.Advance();
return(true);
}
return(false);
}
public SyncTask(bool startedManually, int?taskListId)
{
_startedManually = startedManually;
_taskListId = taskListId;
_dispatcher = Mvx.IoCProvider.Resolve <IMvxMainThreadAsyncDispatcher>();
_syncService = Mvx.IoCProvider.Resolve <ISyncService>();
_logger = Mvx.IoCProvider.Resolve <ILogger>().ForContext <SyncBackgroundTask>();
_textProvider = Mvx.IoCProvider.Resolve <ITextProvider>();
_appSettings = Mvx.IoCProvider.Resolve <IAppSettingsService>();
_messenger = Mvx.IoCProvider.Resolve <IMvxMessenger>();
_dialogService = Mvx.IoCProvider.Resolve <IDialogService>();
_notificationService = Mvx.IoCProvider.Resolve <IAndroidNotificationService>();
_telemetryService = Mvx.IoCProvider.Resolve <ITelemetryService>();
_networkService = Mvx.IoCProvider.Resolve <INetworkService>();
}
public DeleteTaskDialogViewModel(
ITextProvider textProvider,
IMvxMessenger messenger,
ILogger logger,
IMvxNavigationService navigationService,
IAppSettingsService appSettings,
ITelemetryService telemetryService,
IMiraiNotesDataService dataService,
IDialogService dialogService,
IAndroidNotificationService notificationService)
: base(textProvider, messenger, logger.ForContext <DeleteTaskDialogViewModel>(), navigationService, appSettings, telemetryService)
{
_dataService = dataService;
_dialogService = dialogService;
_notificationService = notificationService;
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
ParseArgument(itemFactory, text, tokens);
if (tokens.CurrentToken.TokenType == CssTokenType.Comma)
{
Comma = Children.AddCurrentAndAdvance(tokens, null);
if (ArgumentItems.Count == 0)
{
Comma.AddParseError(ParseErrorType.FunctionArgumentMissing, ParseErrorLocation.BeforeItem);
}
}
return(Children.Count > 0);
}
protected virtual ParseItem CreateDirective(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
ParseItem item = AtDirective.ParseDirective(this, itemFactory, text, tokens);
if (item is AtDirective directive &&
directive.Keyword != null &&
!directive.Keyword.HasParseErrors &&
!IsExpectedDirective(directive))
{
// @directives aren't expected in rules
directive.Keyword.AddParseError(ParseErrorType.UnexpectedAtDirective, ParseErrorLocation.WholeItem);
}
return(item);
}
public ParseItem Create <T>(ComplexItem parent, ITextProvider text, ITokenStream stream) where T : ParseItem, new()
{
var type = typeof(T);
// attempt to create with external factory
ParseItem item = (ExternalItemFactory != null)
? ExternalItemFactory.CreateItem(this, text, stream, parent, type)
: null;
if (item == null)
{
item = new T();
}
return(item);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, RuleName))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
ParseDirective(itemFactory, text, stream);
ParseBlock(itemFactory, text, stream);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
OpenCurlyBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.CurlyBrace);
ParseBody(itemFactory, text, stream);
if (OpenCurlyBrace != null && stream.Current.Type == TokenType.CloseCurlyBrace)
{
CloseCurlyBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.CurlyBrace);
}
}
return(Children.Count > 0);
}
private ParseItem CreateAtRule(ComplexItem parent, ITextProvider text, ITokenStream stream)
{
var nameToken = stream.Peek(1);
if (nameToken.Type == TokenType.Identifier || nameToken.Type == TokenType.Function)
{
var ruleName = text.GetText(nameToken.Start, nameToken.Length);
switch (ruleName)
{
case "mixin": return(new MixinDefinition());
case "content": return(new ContentDirective());
case "include": return(new MixinReference());
case "function": return(new UserFunctionDefinition());
case "import": return(CreateImport(parent, text, stream));
case "extend": return(new ExtendDirective());
case "for": return(new ForLoopDirective());
case "while": return(new WhileLoopDirective());
case "each": return(new EachLoopDirective());
case "if":
case "else":
case "else if": return(new ConditionalControlDirective());
case "media": return(new MediaQueryDirective());
case "font-face": return(new FontFaceDirective());
case "page": return(new PageDirective());
case "charset": return(new CharsetDirective());
case "keyframes": return(new KeyframesDirective());
default: return(new AtRule());
}
}
return(new TokenItem());
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier && text.CompareOrdinal(stream.Current.Start, "and"))
{
Combinator = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
ParseItem feature;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out feature))
{
Feature = feature;
Children.Add(feature);
}
if (stream.Current.Type == TokenType.Colon)
{
Colon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
// dump all values
while (!IsExpressionTerminator(stream.Current.Type))
{
ParseItem value;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out value))
{
FeatureValues.Add(value);
Children.Add(value);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
{
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
return(Children.Count > 0);
}
protected override void ParseDirective(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
switch (stream.Current.Type)
{
case TokenType.String:
CharacterSet = itemFactory.CreateSpecificParsed <StringValue>(this, text, stream);
if (CharacterSet != null)
{
Children.Add(CharacterSet);
}
break;
case TokenType.Identifier:
CharacterSet = Children.AddCurrentAndAdvance(stream);
break;
}
}
private ParseItem CreateVariableDefinitionOrReference(ComplexItem parent, ITextProvider text, ITokenStream stream)
{
var name = stream.Peek(1);
if (name.Type == TokenType.Identifier && stream.Current.End == name.Start)
{
var assignment = stream.Peek(2);
if (assignment.Type == TokenType.Colon || assignment.Type == TokenType.Equal)
{
return(new VariableDefinition());
}
return(new VariableReference());
}
return(new TokenItem());
}
internal static bool IsMediaExpressionStart(ITextProvider text, CssToken token)
{
switch (token.TokenType)
{
case CssTokenType.OpenFunctionBrace:
return(true);
case CssTokenType.Identifier:
if (TextRange.CompareDecoded(token.Start, token.Length, text, "and", true))
{
return(true);
}
break;
}
return(false);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var variable = new VariableDefinition(ExpresionMode.Argument);
if (variable.Parse(itemFactory, text, stream))
{
Variable = variable;
Children.Add(variable);
}
if (stream.Current.Type == TokenType.Comma)
{
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
return(Children.Count > 0);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
// Oddly enough, CSS2 grammar says #124 is a legal selector (#{name},
// where {name}:[nmchar]+ which is different from {ident} that must begin
// with {nmstart} (letter). I don't think it is really true since
// none of W3C samples ever show #123 and id="123" is not valid in XHTML.
CssToken token = tokens.CurrentToken;
if (token.TokenType == CssTokenType.HashName || token.TokenType == CssTokenType.Hash)
{
HashName = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.IdSelector);
ParseAfterName(itemFactory, text, tokens);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var name = new VariableName(SassClassifierType.VariableDefinition);
if (name.Parse(itemFactory, text, stream))
{
Name = name;
Children.Add(name);
}
if (stream.Current.Type == TokenType.Colon)
{
Colon = Children.AddCurrentAndAdvance(stream);
}
while (!IsValueTerminator(Mode, stream))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Values.Add(item);
Children.Add(item);
}
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new DefaultModifier();
if (modifier.Parse(itemFactory, text, stream))
{
Modifier = modifier;
Children.Add(modifier);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (stream.Current.Type == TokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(stream);
}
return(Children.Count > 0);
}
public static int GetLineStart(this ITextProvider textProvider, int position)
{
int start = position;
while (start > 0)
{
char ch = textProvider[start - 1];
if (ch.IsLineBreak())
{
break;
}
start -= 1;
}
return(start);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
CssTokenType tokenType = tokens.CurrentToken.TokenType;
if (tokenType == CssTokenType.CommentText ||
tokenType == CssTokenType.SingleTokenComment ||
tokenType == CssTokenType.SingleLineComment)
{
CssClassifierContextType context = tokenType == CssTokenType.CommentText
? CssClassifierContextType.Default
: CssClassifierContextType.Comment;
Comment = Children.AddCurrentAndAdvance(tokens, context);
}
return(Children.Count > 0);
}
/// <summary>
/// Helper function for derived classes to parse their block
/// </summary>
protected bool ParseBlock(BlockItem block, ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
if (tokens.CurrentToken.TokenType == CssTokenType.OpenCurlyBrace)
{
if (block.Parse(itemFactory, text, tokens))
{
Children.Add(block);
return(true);
}
}
else
{
Children.AddParseError(ParseErrorType.OpenCurlyBraceMissing);
}
return(false);
}
public bool Open(ITextProvider textProvider, TokenStream <RToken> tokens, RFormatOptions options)
{
Debug.Assert(tokens.CurrentToken.TokenType == RTokenType.OpenCurlyBrace);
// When formatting scope in function arguments, use user indent
// where appropriate. User indent can be determined by
// a. current indentation of { if 'braces on new line' is on
// and the open brace indent is deeper than the default.
// b. if the above does not apply, it is equal to the indent
// of the previous line.
// System.Action x = () => {
// }; <<- equal to the statement indent.
// System.Action x = () =>
// { <<- equal to the statement indent.
// };
// System.Action x = () =>
// {
// }; <<- based on the *opening* brace position.
CloseBracePosition = TokenBraceCounter <RToken> .GetMatchingBrace(tokens,
new RToken(RTokenType.OpenCurlyBrace), new RToken(RTokenType.CloseCurlyBrace), new RTokenTypeComparer());
//if (CloseBracePosition > 0)
//{
// if (!IsLineBreakInRange(textProvider, tokens.CurrentToken.End, tokens[CloseBracePosition].Start))
// {
// SuppressLineBreakCount++;
// return true;
// }
//}
if (options.BracesOnNewLine)
{
// If open curly is on its own line (there is only whitespace
// between line break and the curly, find out current indent
// and if it is deeper than the default one, use it,
// otherwise continue with default.
CompareAndSetIndent(textProvider, tokens, tokens.CurrentToken.Start, options);
return(true);
}
return(false);
}
protected override void ParseArgument(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
SimpleSelector simpleSelector = itemFactory.CreateSpecific <SimpleSelector>(this);
if (simpleSelector.ParseInFunction(itemFactory, text, tokens))
{
Selector = simpleSelector;
ArgumentItems.Add(Selector);
Children.Add(Selector);
}
if (tokens.CurrentToken.TokenType != CssTokenType.Comma &&
tokens.CurrentToken.TokenType != CssTokenType.CloseFunctionBrace)
{
Children.AddParseError(ParseErrorType.FunctionArgumentCommaMissing);
}
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
// Parse namespace: foo|bar, *|, *, |A, ..., applies to both elements and attributes
// note that there should not be spaces between namespace, | and name i.e.
// foo | bar are actually three selectors and middle one is missing namespace and name.
//
// Note that we are not going to parse 3|3 as a valid name. Technically we could do it and
// leave validation to verify and squiggle with it, but parsing such construct as a legal
// name would cause colorizer to colorize sequence as an item name which would be confusing
// to the user. I'd rather have it not colorized as legal name and have it apper black instead
// telling customer that it is wrong as she types, well before validation pass hits.
if (tokens.CurrentToken.TokenType == CssTokenType.Identifier || tokens.CurrentToken.TokenType == CssTokenType.Asterisk)
{
// There should be no spaces between namespace, | and the element name
if (tokens.IsWhiteSpaceAfterCurrentToken() || tokens.Peek(1).IsSelectorTerminator())
{
Name = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.ItemName);
}
else if (tokens.Peek(1).TokenType == CssTokenType.Or)
{
// validator will deal with invalid namespaces
Namespace = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.ItemNamespace);
Separator = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Default);
}
}
else if (tokens.CurrentToken.TokenType == CssTokenType.Or)
{
Separator = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Default);
}
if (Name == null && (tokens.CurrentToken.TokenType == CssTokenType.Identifier || tokens.CurrentToken.TokenType == CssTokenType.Asterisk))
{
if (Separator == null || !tokens.IsWhiteSpaceBeforeCurrentToken())
{
Name = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.ItemName);
}
}
else
{
// It is OK for the name to be missing. Lonely | is the same as *|*
// so we are not going to add missing item here
}
return(Children.Count > 0);
}
