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); }