/// <summary> /// Used for formatting the entire document /// </summary> public override string FormatText(PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, string input, int startOffset, int endOffset) { var policy = policyParent.Get<DFormattingPolicy> (mimeTypeChain); var textPolicy = policyParent.Get<TextStylePolicy> (mimeTypeChain); var data = new TextEditorData{ Text = input }; if(IndentCorrectionOnly) { using(var s = data.OpenStream()) using(var r = new StreamReader(s)) D_Parser.Formatting.Indent.IndentEngineWrapper.CorrectIndent(r, startOffset, endOffset, data.Document.Replace, policy.Options, new TextStyleAdapter(textPolicy)); return data.Text; } var ast = DParser.ParseString(input, false, true) as DModule; var formattingVisitor = new DFormattingVisitor(policy.Options, new DocAdapt(data.Document), ast, new TextStyleAdapter(textPolicy)); // Only clip to a region if it's necessary if(startOffset > 0 || endOffset < input.Length-1) { formattingVisitor.CheckFormattingBoundaries = true; var dl = data.Document.OffsetToLocation(startOffset); formattingVisitor.FormattingStartLocation = new D_Parser.Dom.CodeLocation(dl.Column, dl.Line); dl = data.Document.OffsetToLocation(endOffset); formattingVisitor.FormattingEndLocation = new D_Parser.Dom.CodeLocation(dl.Column, dl.Line); } formattingVisitor.WalkThroughAst(); formattingVisitor.ApplyChanges(data.Document.Replace); return data.Text; }
public override void CorrectIndenting (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, TextEditorData data, int line) { DocumentLine lineSegment = data.Document.GetLine (line); if (lineSegment == null) return; try { var policy = policyParent.Get<CSharpFormattingPolicy> (mimeTypeChain); var tracker = new CSharpIndentEngine (data.Document, data.CreateNRefactoryTextEditorOptions (), policy.CreateOptions ()); tracker.Update (lineSegment.Offset); for (int i = lineSegment.Offset; i < lineSegment.Offset + lineSegment.Length; i++) { tracker.Push (data.Document.GetCharAt (i)); } string curIndent = lineSegment.GetIndentation (data.Document); int nlwsp = curIndent.Length; if (!tracker.LineBeganInsideMultiLineComment || (nlwsp < lineSegment.LengthIncludingDelimiter && data.Document.GetCharAt (lineSegment.Offset + nlwsp) == '*')) { // Possibly replace the indent string newIndent = tracker.ThisLineIndent; if (newIndent != curIndent) data.Replace (lineSegment.Offset, nlwsp, newIndent); } } catch (Exception e) { LoggingService.LogError ("Error while indenting", e); } }
public override void CorrectIndenting (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, TextEditorData data, int line) { LineSegment lineSegment = data.Document.GetLine (line); if (lineSegment == null) return; var policy = policyParent.Get<CFormattingPolicy> (mimeTypeChain); var tracker = new DocumentStateTracker<CIndentEngine> (new CIndentEngine (policy), data); tracker.UpdateEngine (lineSegment.Offset); for (int i = lineSegment.Offset; i < lineSegment.Offset + lineSegment.EditableLength; i++) { tracker.Engine.Push (data.Document.GetCharAt (i)); } string curIndent = lineSegment.GetIndentation (data.Document); int nlwsp = curIndent.Length; if (!tracker.Engine.LineBeganInsideMultiLineComment || (nlwsp < lineSegment.Length && data.Document.GetCharAt (lineSegment.Offset + nlwsp) == '*')) { // Possibly replace the indent string newIndent = tracker.Engine.ThisLineIndent; if (newIndent != curIndent) data.Replace (lineSegment.Offset, nlwsp, newIndent); } tracker.Dispose (); }
protected override void CorrectIndentingImplementation (PolicyContainer policyParent, TextEditor editor, int line) { var lineSegment = editor.GetLine (line); if (lineSegment == null) return; try { var policy = policyParent.Get<CSharpFormattingPolicy> (MimeType); var textpolicy = policyParent.Get<TextStylePolicy> (MimeType); var tracker = new CSharpIndentEngine (policy.CreateOptions (textpolicy)); tracker.Update (IdeApp.Workbench.ActiveDocument.Editor, lineSegment.Offset); for (int i = lineSegment.Offset; i < lineSegment.Offset + lineSegment.Length; i++) { tracker.Push (editor.GetCharAt (i)); } string curIndent = lineSegment.GetIndentation (editor); int nlwsp = curIndent.Length; if (!tracker.LineBeganInsideMultiLineComment || (nlwsp < lineSegment.LengthIncludingDelimiter && editor.GetCharAt (lineSegment.Offset + nlwsp) == '*')) { // Possibly replace the indent string newIndent = tracker.ThisLineIndent; if (newIndent != curIndent) editor.ReplaceText (lineSegment.Offset, nlwsp, newIndent); } } catch (Exception e) { LoggingService.LogError ("Error while indenting", e); } }
public string FormatText (PolicyContainer policyParent, string mimeType, string input) { TextStylePolicy policy; if (policyParent != null) policy = policyParent.Get <TextStylePolicy> (DesktopService.GetMimeTypeInheritanceChain (mimeType)); else policy = PolicyService.GetDefaultPolicy <TextStylePolicy> (DesktopService.GetMimeTypeInheritanceChain (mimeType)); XmlTextReader reader = new XmlTextReader (new StringReader (input)); reader.WhitespaceHandling = WhitespaceHandling.None; StringWriter indentedXmlWriter = new StringWriter (); XmlWriterSettings settings = new XmlWriterSettings (); settings.Indent = true; if (policy.TabsToSpaces) { settings.IndentChars = new string (' ', policy.TabWidth); } else { settings.IndentChars = "\t"; } settings.NewLineChars = policy.GetEolMarker (); try { XmlWriter xmlWriter = XmlTextWriter.Create (indentedXmlWriter, settings); xmlWriter.WriteNode (reader, false); xmlWriter.Flush (); } catch { // Ignore malfored xml return input; } return indentedXmlWriter.ToString (); }
static void Format (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, TextEditor editor, DocumentContext context, int startOffset, int endOffset, bool exact, bool formatLastStatementOnly = false, OptionSet optionSet = null) { TextSpan span; if (exact) { span = new TextSpan (startOffset, endOffset - startOffset); } else { span = new TextSpan (0, endOffset); } var analysisDocument = context.AnalysisDocument; if (analysisDocument == null) return; using (var undo = editor.OpenUndoGroup (/*OperationType.Format*/)) { try { var syntaxTree = analysisDocument.GetSyntaxTreeAsync ().Result; if (formatLastStatementOnly) { var root = syntaxTree.GetRoot (); var token = root.FindToken (endOffset); var tokens = ICSharpCode.NRefactory6.CSharp.FormattingRangeHelper.FindAppropriateRange (token); if (tokens.HasValue) { span = new TextSpan (tokens.Value.Item1.SpanStart, tokens.Value.Item2.Span.End - tokens.Value.Item1.SpanStart); } else { var parent = token.Parent; if (parent != null) span = parent.FullSpan; } } if (optionSet == null) { var policy = policyParent.Get<CSharpFormattingPolicy> (mimeTypeChain); var textPolicy = policyParent.Get<TextStylePolicy> (mimeTypeChain); optionSet = policy.CreateOptions (textPolicy); } var doc = Formatter.FormatAsync (analysisDocument, span, optionSet).Result; var newTree = doc.GetSyntaxTreeAsync ().Result; var caretOffset = editor.CaretOffset; int delta = 0; foreach (var change in newTree.GetChanges (syntaxTree)) { if (!exact && change.Span.Start + delta >= caretOffset) continue; var newText = change.NewText; editor.ReplaceText (delta + change.Span.Start, change.Span.Length, newText); delta = delta - change.Span.Length + newText.Length; } var caretEndOffset = caretOffset + delta; if (0 <= caretEndOffset && caretEndOffset < editor.Length) editor.CaretOffset = caretEndOffset; if (editor.CaretColumn == 1) editor.CaretColumn = editor.GetVirtualIndentationColumn (editor.CaretLine); } catch (Exception e) { LoggingService.LogError ("Error in on the fly formatter", e); } } }
public string FormatText (PolicyContainer policyParent, string mimeType, string input, int fromOffset, int toOffset) { if (input == null) throw new ArgumentNullException (nameof (input)); if (mimeType == null) throw new ArgumentNullException (nameof (mimeType)); return FormatImplementation (policyParent ?? PolicyService.DefaultPolicies, mimeType, new StringTextSource (input), fromOffset, toOffset - fromOffset).Text; }
public string FormatText (PolicyContainer policyParent, string mimeType, string input, int fromOffest, int toOffset) { if (policyParent == null) policyParent = PolicyService.DefaultPolicies; if (prettyPrinter != null) return prettyPrinter.FormatText (policyParent, mimeType, input, fromOffest, toOffset); return formatter.FormatText (policyParent, mimeType, input, fromOffest, toOffset); }
public void SetUp() { // Arrange _policyContainer = TestDataFactory.CreateValidPolicyContainer(); // Act _return = _policyContainer.AddPolicy<SomePolicy>(); }
protected override Core.Text.ITextSource FormatImplementation (PolicyContainer policyParent, string mimeType, Core.Text.ITextSource input, int startOffset, int length) { if (policyParent == null) policyParent = PolicyService.DefaultPolicies; var txtPol = policyParent.Get<TextStylePolicy> (mimeType); var xmlPol = policyParent.Get<XmlFormattingPolicy> (mimeType); return new StringTextSource(FormatXml (txtPol, xmlPol, input.Text)); }
public void SetUp() { // Arrange _policy = new DenyAnonymousAccessPolicy(); _policyContainer = TestDataFactory.CreateValidPolicyContainer(); // Act _return = _policyContainer.AddPolicy(_policy); }
public ITextSource Format (PolicyContainer policyParent, string mimeType, ITextSource input, int startOffset, int length) { if (startOffset < 0 || startOffset > input.Length) throw new ArgumentOutOfRangeException (nameof (startOffset), "should be >= 0 && < " + input.Length + " was:" + startOffset); if (length < 0 || startOffset + length > input.Length) throw new ArgumentOutOfRangeException (nameof (length), "should be >= 0 && < " + (input.Length - startOffset) + " was:" + length); try { return FormatImplementation (policyParent ?? PolicyService.DefaultPolicies, mimeType, input, startOffset, length); } catch (Exception e) { LoggingService.LogError ("Error while formatting text.", e); } return input.CreateSnapshot (startOffset, length); }
public string FormatText (PolicyContainer policyParent, string input, ISegment segment = null) { try { if (segment == null) return formatter.FormatText (policyParent, mimeType, input, 0, input.Length); return formatter.FormatText (policyParent, mimeType, input, segment.Offset, segment.EndOffset); } catch (Exception e) { LoggingService.LogError ("Error while formatting text.", e); if (segment == null) return input; return input.Substring (segment.Offset, segment.Length); } }
public ITextSource Format (PolicyContainer policyParent, ITextSource input, ISegment segment = null) { try { if (segment == null) return formatter.Format (policyParent, mimeType, input); return formatter.Format (policyParent, mimeType, input, segment.Offset, segment.EndOffset); } catch (Exception e) { LoggingService.LogError ("Error while formatting text.", e); if (segment == null) return input; return input.CreateSnapshot (segment.Offset, segment.Length); } }
public static string GetPoliciesDescription(PolicyContainer pset) { Dictionary <string, List <string> > content = new Dictionary <string, List <string> > (); foreach (var p in pset.DirectGetAll()) { string name = PolicyService.GetPolicyTypeDescription(p.PolicyType); List <string> scopes; if (!content.TryGetValue(name, out scopes)) { scopes = content [name] = new List <string> (); } scopes.Add(p.Scope ?? ""); } var sorted = content.ToList(); sorted.Sort((x, y) => x.Key.CompareTo(y.Key)); StringBuilder sb = new StringBuilder(); foreach (var pol in sorted) { if (sb.Length > 0) { sb.Append('\n'); } sb.Append(pol.Key); if (pol.Value.Count != 1 || pol.Value[0].Length != 0) { sb.Append(" ("); bool first = true; if (pol.Value.Remove("")) { sb.Append(GettextCatalog.GetString("default settings")); first = false; } foreach (var s in pol.Value) { if (!first) { sb.Append(", "); } sb.Append(s); first = false; } sb.Append(")"); } } return(sb.ToString()); }
/// <summary> /// Formats a text document directly with insert/remove operations. /// </summary> /// <param name="textEditorData"> /// A <see cref="System.Object"/> that must be from type Mono.TextEditorData. /// </param> /// <param name="dom"> /// A <see cref="ProjectDom"/> /// </param> /// <param name="unit"> /// A <see cref="ICompilationUnit"/> /// </param> /// <param name="caretLocation"> /// A <see cref="DomLocation"/> that should be the end location to which the parsing should occur. /// </param> public void OnTheFlyFormat(PolicyContainer policyParent, TextEditorData data, IType callingType, IMember callingMember, ProjectDom dom, ICompilationUnit unit, DomLocation endLocation) { var adv = formatter as IAdvancedCodeFormatter; if (adv == null || !adv.SupportsOnTheFlyFormatting) { throw new InvalidOperationException("On the fly formatting not supported"); } adv.OnTheFlyFormat(policyParent ?? PolicyService.DefaultPolicies, mimeTypeChain, data, callingType, callingMember, dom, unit, endLocation); }
protected override ITextSource FormatImplementation(PolicyContainer policyParent, string mimeType, ITextSource input, int startOffset, int length) { var currentPolicy = policyParent.Get <TextStylePolicy> (mimeType); int line = 0, col = 0; string eolMarker = currentPolicy.GetEolMarker(); var result = new StringBuilder(); var endOffset = startOffset + length; for (int i = startOffset; i < endOffset && i < input.Length; i++) { char ch = input[i]; switch (ch) { case '\t': if (currentPolicy.TabsToSpaces) { int tabWidth = GetNextTabstop(col, currentPolicy.TabWidth) - col; result.Append(new string (' ', tabWidth)); col += tabWidth; } else { goto default; } break; case '\r': if (i + 1 < input.Length && input[i + 1] == '\n') { i++; } goto case '\n'; case '\n': result.Append(eolMarker); line++; col = 0; break; default: result.Append(ch); col++; break; } } return(new StringTextSource(result.ToString(), input.Encoding, input.UseBOM)); }
public override string FormatText(PolicyContainer policyParent, IEnumerable <string> mimeTypeChain, string input, int startOffset, int endOffset) { var currentPolicy = policyParent.Get <TextStylePolicy> (mimeTypeChain); input = input ?? ""; int line = 0, col = 0; string eolMarker = currentPolicy.GetEolMarker(); var result = new StringBuilder(); for (int i = startOffset; i < endOffset && i < input.Length; i++) { char ch = input[i]; switch (ch) { case '\t': if (currentPolicy.TabsToSpaces) { int tabWidth = GetNextTabstop(col, currentPolicy.TabWidth) - col; result.Append(new string (' ', tabWidth)); col += tabWidth; } else { goto default; } break; case '\r': if (i + 1 < input.Length && input[i + 1] == '\n') { i++; } goto case '\n'; case '\n': result.Append(eolMarker); line++; col = 0; break; default: result.Append(ch); col++; break; } } return(result.ToString()); }
public override void Initialize(MonoDevelop.Ide.Gui.Dialogs.OptionsDialog dialog, object dataObject) { base.Initialize(dialog, dataObject); IPolicyProvider provider = dataObject as IPolicyProvider; if (provider == null) { provider = PolicyService.GetUserDefaultPolicySet(); isGlobalPolicy = true; } policyContainer = provider.Policies; bag = policyContainer as PolicyBag; polSet = policyContainer as PolicySet; policyContainer.PolicyChanged += HandlePolicyContainerPolicyChanged; }
public void CorrectIndenting(PolicyContainer policyParent, TextEditor editor, int line) { if (policyParent == null) { throw new ArgumentNullException(nameof(policyParent)); } if (editor == null) { throw new ArgumentNullException(nameof(editor)); } if (line < 1 || line > editor.LineCount) { throw new ArgumentOutOfRangeException(nameof(line), "should be >= 1 && <= " + editor.LineCount + " was:" + line); } CorrectIndentingImplementation(policyParent, editor, line); }
public void OnTheFlyFormat(PolicyContainer policyParent, TextEditorData data, int startOffset, int endOffset) { var adv = formatter as IAdvancedCodeFormatter; if (adv == null || !adv.SupportsOnTheFlyFormatting) { throw new InvalidOperationException("On the fly formatting not supported"); } if (startOffset >= endOffset) { return; } adv.OnTheFlyFormat(policyParent ?? PolicyService.DefaultPolicies, mimeTypeChain, data, startOffset, endOffset); }
public override void Initialize(MonoDevelop.Ide.Gui.Dialogs.OptionsDialog dialog, object dataObject) { base.Initialize(dialog, dataObject); if (dataObject is SolutionItem) { policyContainer = bag = ((SolutionItem)dataObject).Policies; } else if (dataObject is Solution) { policyContainer = bag = ((Solution)dataObject).Policies; } else if (dataObject is PolicySet) { policyContainer = polSet = ((PolicySet)dataObject); } }
public void UpdateStyleParent (Project styleParent, string mimeType) { if (policyContainer != null) policyContainer.PolicyChanged -= HandlePolicyChanged; if (string.IsNullOrEmpty (mimeType)) mimeType = "text/plain"; this.mimeTypes = DesktopService.GetMimeTypeInheritanceChain (mimeType); if (styleParent != null) policyContainer = styleParent.Policies; else policyContainer = MonoDevelop.Projects.Policies.PolicyService.DefaultPolicies; currentPolicy = policyContainer.Get<TextStylePolicy> (mimeTypes); policyContainer.PolicyChanged += HandlePolicyChanged; }
public ITextSource Format(PolicyContainer policyParent, ITextSource input, ISegment segment = null) { try { if (segment == null) { return(formatter.Format(policyParent, mimeType, input)); } return(formatter.Format(policyParent, mimeType, input, segment.Offset, segment.EndOffset)); } catch (Exception e) { LoggingService.LogError("Error while formatting text.", e); if (segment == null) { return(input); } return(input.CreateSnapshot(segment.Offset, segment.Length)); } }
/// <summary>Formats a subrange of the input text.</summary> /// <returns>The formatted text of the range.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException">When the offsets are out of bounds.</exception> public string FormatText(PolicyContainer policyParent, string input, int fromOffset, int toOffset) { if (fromOffset < 0 || fromOffset > input.Length) { throw new ArgumentOutOfRangeException("fromOffset", "should be >= 0 && < " + input.Length + " was:" + fromOffset); } if (toOffset < 0 || toOffset > input.Length) { throw new ArgumentOutOfRangeException("fromOffset", "should be >= 0 && < " + input.Length + " was:" + toOffset); } try { return(formatter.FormatText(policyParent ?? PolicyService.DefaultPolicies, mimeTypeChain, input, fromOffset, toOffset)); } catch (Exception e) { LoggingService.LogError("Error while formatting text.", e); } return(input.Substring(fromOffset, toOffset - fromOffset)); }
public string FormatText(PolicyContainer policyParent, string input, ISegment segment = null) { try { if (segment == null) { return(formatter.FormatText(policyParent, mimeType, input, 0, input.Length)); } return(formatter.FormatText(policyParent, mimeType, input, segment.Offset, segment.EndOffset)); } catch (Exception e) { LoggingService.LogError("Error while formatting text.", e); if (segment == null) { return(input); } return(input.Substring(segment.Offset, segment.Length)); } }
void UpdateDefaultSettingsButton(PolicyContainer initialContainer) { if (defaultSettingsButton != null) { T pol = GetDirectInherited(initialContainer); if (pol != null) { panelWidget.Sensitive = true; defaultSettingsButton.Active = false; } else { panelWidget.Sensitive = false; defaultSettingsButton.Active = true; } } }
public void Should_return_unique_results() { // Arrange var firstPolicy = new IgnorePolicy(); var policyContainer = new PolicyContainer(TestDataFactory.ValidControllerName, TestDataFactory.ValidActionName, TestDataFactory.CreateValidPolicyAppender()); policyContainer.SecurityConfigurationProvider = () => TestDataFactory.CreateValidSecurityConfiguration(configuration => configuration.Advanced.SetDefaultResultsCacheLifecycle(Cache.DoNotCache)); policyContainer.AddPolicy(firstPolicy); // Act var context = TestDataFactory.CreateSecurityContext(false); var results1 = policyContainer.EnforcePolicies(context); var results2 = policyContainer.EnforcePolicies(context); // Assert Assert.That(results1.Single(), Is.Not.EqualTo(results2.Single())); }
public ITextSource Format(PolicyContainer policyParent, string mimeType, ITextSource input, int startOffset, int length) { if (startOffset < 0 || startOffset > input.Length) { throw new ArgumentOutOfRangeException(nameof(startOffset), "should be >= 0 && < " + input.Length + " was:" + startOffset); } if (length < 0 || startOffset + length > input.Length) { throw new ArgumentOutOfRangeException(nameof(length), "should be >= 0 && < " + (input.Length - startOffset) + " was:" + length); } try { return(FormatImplementation(policyParent ?? PolicyService.DefaultPolicies, mimeType, input, startOffset, length)); } catch (Exception e) { LoggingService.LogError("Error while formatting text.", e); } return(input.CreateSnapshot(startOffset, length)); }
public override void Initialize (MonoDevelop.Ide.Gui.Dialogs.OptionsDialog dialog, object dataObject) { base.Initialize (dialog, dataObject); if (dataObject is SolutionItem) { policyContainer = ((SolutionItem)dataObject).Policies; } else if (dataObject is Solution) { policyContainer = ((Solution)dataObject).Policies; } else if (dataObject is PolicySet) { policyContainer = ((PolicySet)dataObject); globalMimeTypes = new List<string> (); string userTypes = PropertyService.Get<string> ("MonoDevelop.Projects.GlobalPolicyMimeTypes", ""); globalMimeTypes.AddRange (userTypes.Split (new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries)); } foreach (string mt in GetItemMimeTypes ()) AddPanel (mt); }
T GetDirectInherited(PolicyContainer initialContainer) { if (initialContainer == policyContainer && !loaded && hasCachedPolicy) { return((T)cachedPolicy); } PolicyContainer pc = initialContainer; while (pc != null) { if (pc.DirectHas <T> (mimeType)) { return(pc.DirectGet <T> (mimeType)); } pc = pc.ParentPolicies; } return(PolicyService.GetUserDefaultPolicySet().Get <T> (mimeType)); }
public override void Initialize(MonoDevelop.Ide.Gui.Dialogs.OptionsDialog dialog, object dataObject) { base.Initialize(dialog, dataObject); IPolicyProvider provider = dataObject as IPolicyProvider; if (provider == null) { provider = PolicyService.GetUserDefaultPolicySet(); // When editing the global user preferences, the default values for policies are the IDE default values. defaultPolicyContainer = PolicyService.SystemDefaultPolicies; isGlobalPolicy = true; } policyContainer = provider.Policies; bag = policyContainer as PolicyBag; polSet = policyContainer as PolicySet; policyContainer.PolicyChanged += HandlePolicyContainerPolicyChanged; }
protected override string InternalFormat(PolicyContainer policyParent, string mimeType, string input, int startOffset, int endOffset) { string text = GetFormattedText(policyParent, input); if (startOffset == 0 && endOffset >= input.Length - 1) { return(text); } int newStartOffset = TranslateOffset(input, text, startOffset); int newEndOffset = TranslateOffset(input, text, endOffset); if (newStartOffset < 0 || newEndOffset < 0) { return(input.Substring(startOffset, System.Math.Max(0, System.Math.Min(endOffset - startOffset, input.Length - startOffset)))); } return(text.Substring(newStartOffset, newEndOffset - newStartOffset)); }
/// <summary> /// Used for formatting the entire document /// </summary> public override string FormatText(PolicyContainer policyParent, IEnumerable <string> mimeTypeChain, string input, int startOffset, int endOffset) { var policy = policyParent.Get <DFormattingPolicy> (mimeTypeChain); var textPolicy = policyParent.Get <TextStylePolicy> (mimeTypeChain); var data = new TextEditorData { Text = input }; if (IndentCorrectionOnly) { using (data.Document.OpenUndoGroup()) using (var s = data.OpenStream()) using (var r = new StreamReader(s)) D_Parser.Formatting.Indent.IndentEngineWrapper.CorrectIndent(r, startOffset, endOffset, data.Document.Replace, policy.Options, new TextStyleAdapter(textPolicy) { KeepAlignmentSpaces = policy.KeepAlignmentSpaces }); return(data.Text); } var ast = DParser.ParseString(input, false, true); var formattingVisitor = new DFormattingVisitor(policy.Options, new DocAdapt(data.Document), ast, new TextStyleAdapter(textPolicy)); // Only clip to a region if it's necessary if (startOffset > 0 || endOffset < input.Length - 1) { formattingVisitor.CheckFormattingBoundaries = true; var dl = data.Document.OffsetToLocation(startOffset); formattingVisitor.FormattingStartLocation = new CodeLocation(dl.Column, dl.Line); dl = data.Document.OffsetToLocation(endOffset); formattingVisitor.FormattingEndLocation = new CodeLocation(dl.Column, dl.Line); } formattingVisitor.WalkThroughAst(); using (data.Document.OpenUndoGroup()) formattingVisitor.ApplyChanges(data.Document.Replace); return(data.Text); }
public string FormatText(PolicyContainer policyParent, string mimeType, string input) { TextStylePolicy policy; if (policyParent != null) { policy = policyParent.Get <TextStylePolicy> (DesktopService.GetMimeTypeInheritanceChain(mimeType)); } else { policy = PolicyService.GetDefaultPolicy <TextStylePolicy> (DesktopService.GetMimeTypeInheritanceChain(mimeType)); } XmlTextReader reader = new XmlTextReader(new StringReader(input)); reader.WhitespaceHandling = WhitespaceHandling.None; StringWriter indentedXmlWriter = new StringWriter(); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; if (policy.TabsToSpaces) { settings.IndentChars = new string (' ', policy.TabWidth); } else { settings.IndentChars = "\t"; } settings.NewLineChars = policy.GetEolMarker(); try { XmlWriter xmlWriter = XmlTextWriter.Create(indentedXmlWriter, settings); xmlWriter.WriteNode(reader, false); xmlWriter.Flush(); } catch { // Ignore malfored xml return(input); } return(indentedXmlWriter.ToString()); }
public void Should_add_policyresult_cache_strategy_for_RequireRolePolicy_with_lifecycle_set_to_DoNotCache() { const Cache expectedLifecycle = Cache.DoNotCache; const string expectedControllerName = "Controller1"; const string expectedActionName = "Action1"; var policyContainer = new PolicyContainer(expectedControllerName, expectedActionName, TestDataFactory.CreateValidPolicyAppender()); // Act policyContainer.Cache <RequireRolePolicy>(expectedLifecycle); // Assert var policyResultCacheStrategy = policyContainer.CacheStrategies.Single(); Assert.That(policyResultCacheStrategy.ControllerName, Is.EqualTo(expectedControllerName)); Assert.That(policyResultCacheStrategy.ActionName, Is.EqualTo(expectedActionName)); Assert.That(policyResultCacheStrategy.PolicyType, Is.EqualTo(typeof(RequireRolePolicy))); Assert.That(policyResultCacheStrategy.CacheLifecycle, Is.EqualTo(expectedLifecycle)); Assert.That(policyResultCacheStrategy.CacheLevel, Is.EqualTo(By.ControllerAction)); }
public void Should_add_policyresult_cache_strategy_for_DenyAnonymousAccessPolicy_with_lifecycle_set_to_PerHttpRequest() { const Cache expectedLifecycle = Cache.PerHttpRequest; const string expectedControllerName = "Controller4"; const string expectedActionName = "Action4"; var policyContainer = new PolicyContainer(expectedControllerName, expectedActionName, TestDataFactory.CreateValidPolicyAppender()); // Act policyContainer.Cache <DenyAnonymousAccessPolicy>(expectedLifecycle); // Assert var policyResultCacheStrategy = policyContainer.CacheStrategies.Single(); Assert.That(policyResultCacheStrategy.ControllerName, Is.EqualTo(expectedControllerName)); Assert.That(policyResultCacheStrategy.ActionName, Is.EqualTo(expectedActionName)); Assert.That(policyResultCacheStrategy.PolicyType, Is.EqualTo(typeof(DenyAnonymousAccessPolicy))); Assert.That(policyResultCacheStrategy.CacheLifecycle, Is.EqualTo(expectedLifecycle)); Assert.That(policyResultCacheStrategy.CacheLevel, Is.EqualTo(By.ControllerAction)); }
public static void FormatFile(PolicyContainer policies, FilePath fileName) { CodeFormatter formatter = GetFormatter(fileName); if (formatter == null) { return; } try { string content = File.ReadAllText(fileName); string formatted = formatter.FormatText(policies, content); if (formatted != null) { TextFileUtility.WriteText(fileName, formatted, Encoding.UTF8); } } catch (Exception ex) { TemplatingServices.LogError("File formatting failed", ex); } }
public static void SetFormatOptions(CSharpOutputVisitor outputVisitor, PolicyContainer policyParent) { IEnumerable <string> types = DesktopService.GetMimeTypeInheritanceChain(MimeType); TextStylePolicy currentPolicy = policyParent != null?policyParent.Get <TextStylePolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <TextStylePolicy> (types); CSharpFormattingPolicy codePolicy = policyParent != null?policyParent.Get <CSharpFormattingPolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <CSharpFormattingPolicy> (types); outputVisitor.Options.IndentationChar = currentPolicy.TabsToSpaces ? ' ' : '\t'; outputVisitor.Options.TabSize = currentPolicy.TabWidth; outputVisitor.Options.IndentSize = currentPolicy.TabWidth; outputVisitor.Options.EolMarker = TextStylePolicy.GetEolMarker(currentPolicy.EolMarker); CodeFormatDescription descr = CSharpFormattingPolicyPanel.CodeFormatDescription; Type optionType = outputVisitor.Options.GetType(); foreach (CodeFormatOption option in descr.AllOptions) { KeyValuePair <string, string> val = descr.GetValue(codePolicy, option); PropertyInfo info = optionType.GetProperty(option.Name); if (info == null) { System.Console.WriteLine("option : " + option.Name + " not found."); continue; } object cval = null; if (info.PropertyType.IsEnum) { cval = Enum.Parse(info.PropertyType, val.Key); } else if (info.PropertyType == typeof(bool)) { cval = Convert.ToBoolean(val.Key); } else { cval = Convert.ChangeType(val.Key, info.PropertyType); } //System.Console.WriteLine("set " + option.Name + " to " + cval); info.SetValue(outputVisitor.Options, cval, null); } }
public void Should_invoke_the_isautheticated_and_roles_functions() { // Arrange var context = MockRepository.GenerateMock <ISecurityContext>(); context.Expect(x => x.CurrenUserAuthenticated()).Return(true).Repeat.Once(); context.Expect(x => x.CurrenUserRoles()).Return(new List <object> { UserRole.Owner }.ToArray()).Repeat.Once(); context.Replay(); var policyContainer = new PolicyContainer(TestDataFactory.ValidControllerName, TestDataFactory.ValidActionName, TestDataFactory.CreateValidPolicyAppender()); policyContainer.AddPolicy(new TestPolicy()); // Act policyContainer.EnforcePolicies(context); // Assert context.VerifyAllExpectations(); }
public static void Format (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, TextEditorData data, ProjectDom dom, DomLocation location, bool correctBlankLines) { var compilationUnit = new MonoDevelop.CSharp.Parser.CSharpParser ().Parse (data); var policy = policyParent.Get<CSharpFormattingPolicy> (mimeTypeChain); var domSpacingVisitor = new DomSpacingVisitor (policy, data) { AutoAcceptChanges = false, }; compilationUnit.AcceptVisitor (domSpacingVisitor, null); var domIndentationVisitor = new DomIndentationVisitor (policy, data) { AutoAcceptChanges = false, }; domIndentationVisitor.CorrectBlankLines = correctBlankLines; compilationUnit.AcceptVisitor (domIndentationVisitor, null); var changes = new List<Change> (); changes.AddRange (domSpacingVisitor.Changes); changes.AddRange (domIndentationVisitor.Changes); RefactoringService.AcceptChanges (null, null, changes); }
protected override string InternalFormat (PolicyContainer policyParent, string mimeType, string input, int startOffset, int endOffset) { IEnumerable<string> mtypes = DesktopService.GetMimeTypeInheritanceChain (mimeType); TextStylePolicy currentPolicy = policyParent != null ? policyParent.Get<TextStylePolicy> (mtypes) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<TextStylePolicy> (mtypes); input = input ?? ""; int line = 0, col = 0; string eolMarker = currentPolicy.GetEolMarker (); StringBuilder result = new StringBuilder (); for (int i = startOffset; i <= endOffset; i++) { char ch = input[i]; switch (ch) { case '\t': if (currentPolicy.TabsToSpaces) { int tabWidth = GetNextTabstop (col, currentPolicy.TabWidth) - col; result.Append (new string (' ', tabWidth)); col += tabWidth; } else goto default; break; case '\r': if (i + 1 < input.Length && input[i + 1] == '\n') i++; goto case '\n'; case '\n': result.Append (eolMarker); line++; col = 0; break; default: result.Append (ch); col++; break; } } return result.ToString (); }
async Task UpdateTextEditorOptionsAsync() { UpdateLineNumberMarginOption(); var foldMargin = PropertyService.Get <bool> ("ShowFoldMargin"); Imports.OutliningManagerService.GetOutliningManager(TextView).Enabled = foldMargin; var newPolicyContainer = (Owner as IPolicyProvider)?.Policies; if (newPolicyContainer != policyContainer) { if (policyContainer != null) { policyContainer.PolicyChanged -= PolicyChanged; } policyContainer = newPolicyContainer; } if (policyContainer != null) { policyContainer.PolicyChanged += PolicyChanged; } var newEditorConfigContext = await EditorConfigService.GetEditorConfigContext(FilePath, default); if (newEditorConfigContext != editorConfigContext) { if (editorConfigContext != null) { editorConfigContext.CodingConventionsChangedAsync -= UpdateOptionsFromEditorConfigAsync; } editorConfigContext = newEditorConfigContext; } if (editorConfigContext != null) { editorConfigContext.CodingConventionsChangedAsync += UpdateOptionsFromEditorConfigAsync; } await UpdateOptionsFromEditorConfigAsync(null, null); }
public void Should_update_existing_policyresult_cache_strategies() { // Arrange const Cache expectedLifecycle = Cache.PerHttpSession; const string expectedControllerName = "Controller6"; const string expectedActionName = "Action6"; var policyContainer = new PolicyContainer(expectedControllerName, expectedActionName, TestDataFactory.CreateValidPolicyAppender()); // Act policyContainer .Cache <RequireAllRolesPolicy>(Cache.PerHttpRequest) .Cache <RequireAllRolesPolicy>(Cache.PerHttpSession); // Assert var policyResultCacheStrategy = policyContainer.CacheStrategies.Single(); Assert.That(policyResultCacheStrategy.ControllerName, Is.EqualTo(expectedControllerName)); Assert.That(policyResultCacheStrategy.ActionName, Is.EqualTo(expectedActionName)); Assert.That(policyResultCacheStrategy.PolicyType, Is.EqualTo(typeof(RequireAllRolesPolicy))); Assert.That(policyResultCacheStrategy.CacheLifecycle, Is.EqualTo(expectedLifecycle)); Assert.That(policyResultCacheStrategy.CacheLevel, Is.EqualTo(By.ControllerAction)); }
public void Should_enforce_lazy_policy_with_cache_key_exactly_twice_during_execution_with_caching_on() { // Arrange var callsToContainer = 0; var policy = new LazyLoadedPolicyWithCacheKey(); FakeIoC.GetAllInstancesProvider = () => { callsToContainer++; return(new List <object> { policy }); }; SecurityConfigurator.Configure(configuration => { configuration.GetAuthenticationStatusFrom(TestDataFactory.ValidIsAuthenticatedFunction); configuration.ResolveServicesUsing(FakeIoC.GetAllInstances); configuration.Advanced.SetDefaultResultsCacheLifecycle(Cache.PerHttpRequest); }); var context = new MockSecurityContext(); var policyContainer = new PolicyContainer(TestDataFactory.ValidControllerName, TestDataFactory.ValidActionName, TestDataFactory.CreateValidPolicyAppender()); policyContainer.AddPolicy <LazyLoadedPolicyWithCacheKey>(); // Act policy.CacheKey = "101"; policyContainer.EnforcePolicies(context); policyContainer.EnforcePolicies(context); policyContainer.EnforcePolicies(context); policy.CacheKey = "102"; policyContainer.EnforcePolicies(context); policyContainer.EnforcePolicies(context); // Assert Assert.That(callsToContainer, Is.EqualTo(5)); Assert.That(policy.CacheKeyCallCount, Is.EqualTo(5), "Did not get the custom cache key the expected amount of times"); Assert.That(policy.EnforceCallCount, Is.EqualTo(2), "Did not call enforce the expected amount of times"); }
public void Should_enforce_policies_with_context() { // Arrange var roles = new List<object> { UserRole.Owner }.ToArray(); const bool isAuthenticated = true; var context = new Mock<ISecurityContext>(); context.Setup(x => x.CurrenUserAuthenticated()).Returns(isAuthenticated); context.Setup(x => x.CurrenUserRoles()).Returns(roles); var policy = new Mock<ISecurityPolicy>(); policy.Setup(x => x.Enforce(It.Is<ISecurityContext>(c => c.CurrenUserAuthenticated() == isAuthenticated && c.CurrenUserRoles() == roles))).Returns(PolicyResult.CreateSuccessResult(policy.Object)); var policyContainer = new PolicyContainer(TestDataFactory.ValidControllerName, TestDataFactory.ValidActionName, TestDataFactory.CreateValidPolicyAppender()); policyContainer.AddPolicy(policy.Object); // Act policyContainer.EnforcePolicies(context.Object); // Assert policy.VerifyAll(); }
public override void OnTheFlyFormat(PolicyContainer policyParent, IEnumerable <string> mimeTypeChain, TextEditorData data, int startOffset, int endOffset) { var parser = new MonoDevelop.CSharp.Parser.CSharpParser(); var compilationUnit = parser.Parse(data); bool hadErrors = parser.ErrorReportPrinter.ErrorsCount + parser.ErrorReportPrinter.FatalCounter > 0; var policy = policyParent.Get <CSharpFormattingPolicy> (mimeTypeChain); var formattingVisitor = new AstFormattingVisitor(policy, data) { AutoAcceptChanges = false, }; compilationUnit.AcceptVisitor(formattingVisitor, null); var changes = new List <Change> (); changes.AddRange(formattingVisitor.Changes. Where(c => c is TextReplaceChange && (startOffset <= ((TextReplaceChange)c).Offset && ((TextReplaceChange)c).Offset < endOffset))); RefactoringService.AcceptChanges(null, null, changes); }
protected override ITextSource FormatImplementation(PolicyContainer policyParent, string mimeType, ITextSource input, int startOffset, int length) { var chain = IdeServices.DesktopService.GetMimeTypeInheritanceChain(mimeType); var policy = policyParent.Get <CSharpFormattingPolicy> (chain); var textPolicy = policyParent.Get <TextStylePolicy> (chain); var optionSet = policy.CreateOptions(textPolicy); if (input is IReadonlyTextDocument doc) { try { var conventions = EditorConfigService.GetEditorConfigContext(doc.FileName).WaitAndGetResult(); if (conventions != null) { optionSet = new FormattingDocumentOptionSet(optionSet, new DocumentOptions(optionSet, conventions.CurrentConventions)); } } catch (Exception e) { LoggingService.LogError("Error while loading coding conventions.", e); } } return(new StringTextSource(FormatText(optionSet, input.Text, startOffset, startOffset + length))); }
public override string FormatText (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, string input, int startOffset, int endOffset) { var currentPolicy = policyParent.Get<TextStylePolicy> (mimeTypeChain); input = input ?? ""; int line = 0, col = 0; string eolMarker = currentPolicy.GetEolMarker (); var result = new StringBuilder (); for (int i = startOffset; i <= endOffset && i < input.Length; i++) { char ch = input[i]; switch (ch) { case '\t': if (currentPolicy.TabsToSpaces) { int tabWidth = GetNextTabstop (col, currentPolicy.TabWidth) - col; result.Append (new string (' ', tabWidth)); col += tabWidth; } else goto default; break; case '\r': if (i + 1 < input.Length && input[i + 1] == '\n') i++; goto case '\n'; case '\n': result.Append (eolMarker); line++; col = 0; break; default: result.Append (ch); col++; break; } } return result.ToString (); }
public override void Initialize (MonoDevelop.Ide.Gui.Dialogs.OptionsDialog dialog, object dataObject) { base.Initialize (dialog, dataObject); foreach (MimeTypeOptionsPanelNode node in AddinManager.GetExtensionNodes ("/MonoDevelop/ProjectModel/Gui/MimeTypePolicyPanels")) mimeTypesWithPolicies.Add (node.MimeType); var provider = dataObject as IPolicyProvider; if (provider == null) provider = PolicyService.GetUserDefaultPolicySet (); policyContainer = provider.Policies; if (!(dataObject is SolutionItem) && !(dataObject is Solution)) { globalMimeTypes = new List<string> (); string userTypes = PropertyService.Get<string> ("MonoDevelop.Projects.GlobalPolicyMimeTypes", ""); globalMimeTypes.AddRange (userTypes.Split (new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries)); } foreach (string mt in GetItemMimeTypes ()) AddPanel (mt); policyContainer.PolicyChanged += HandlePolicyContainerPolicyChanged; }
protected override ITextSource FormatImplementation (PolicyContainer policyParent, string mimeType, ITextSource input, int startOffset, int length) { var currentPolicy = policyParent.Get<TextStylePolicy> (mimeType); int line = 0, col = 0; string eolMarker = currentPolicy.GetEolMarker (); var result = new StringBuilder (); var endOffset = startOffset + length; for (int i = startOffset; i < endOffset && i < input.Length; i++) { char ch = input[i]; switch (ch) { case '\t': if (currentPolicy.TabsToSpaces) { int tabWidth = GetNextTabstop (col, currentPolicy.TabWidth) - col; result.Append (new string (' ', tabWidth)); col += tabWidth; } else goto default; break; case '\r': if (i + 1 < input.Length && input[i + 1] == '\n') i++; goto case '\n'; case '\n': result.Append (eolMarker); line++; col = 0; break; default: result.Append (ch); col++; break; } } return new StringTextSource (result.ToString (), input.Encoding, input.UseBOM); }
public override string FormatText (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, string input, int startOffset, int endOffset) { var policy = policyParent.Get<CSharpFormattingPolicy> (mimeTypeChain); var textPolicy = policyParent.Get<TextStylePolicy> (mimeTypeChain); return FormatText (policy, textPolicy, mimeTypeChain.First (), input, startOffset, endOffset); }
public override void OnTheFlyFormat (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, TextEditorData data, int startOffset, int endOffset) { var parser = new CSharpParser (); var compilationUnit = parser.ParseSnippet (data); if (compilationUnit == null) { Console.WriteLine ("couldn't parse : " + data.Text); return; } if (parser.HasErrors) return; var policy = policyParent.Get<CSharpFormattingPolicy> (mimeTypeChain); var adapter = new TextEditorDataAdapter (data); var formattingVisitor = new ICSharpCode.NRefactory.CSharp.AstFormattingVisitor (policy.CreateOptions (), adapter, new FormattingActionFactory (data)) { HadErrors = parser.HasErrors }; var changes = new List<ICSharpCode.NRefactory.CSharp.Refactoring.Action> (); changes.AddRange (formattingVisitor.Changes. Where (c => (startOffset <= c.Offset && c.Offset < endOffset))); using (var undo = data.OpenUndoGroup ()) { MDRefactoringContext.MdScript.RunActions (changes, null); } }
public override void OnTheFlyFormat (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, TextEditorData data, IType type, IMember member, ProjectDom dom, ICompilationUnit unit, DomLocation caretLocation) { // OnTheFlyFormatter.Format (policyParent, mimeTypeChain, data, dom, caretLocation, true); }
string GetFormattedText (PolicyContainer policyParent, string input) { hasErrors = false; if (string.IsNullOrEmpty (input)) return input; CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor (); SetFormatOptions (outputVisitor, policyParent); outputVisitor.OutputFormatter.IndentationLevel = startIndentLevel; using (ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser (SupportedLanguage.CSharp, new StringReader (input))) { parser.Parse (); hasErrors = parser.Errors.Count != 0; // if (hasErrors) // Console.WriteLine (parser.Errors.ErrorOutput); IList<ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials (); if (parser.Errors.Count == 0) { using (SpecialNodesInserter.Install (specials, outputVisitor)) { parser.CompilationUnit.AcceptVisitor (outputVisitor, null); } return outputVisitor.Text; } } // Console.WriteLine ("trying to parse block."); using (ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser (SupportedLanguage.CSharp, new StringReader (input))) { BlockStatement blockStatement = parser.ParseBlock (); hasErrors = parser.Errors.Count != 0; // if (hasErrors) // Console.WriteLine (parser.Errors.ErrorOutput); IList<ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials (); if (parser.Errors.Count == 0) { StringBuilder result = new StringBuilder (); using (var inserter = SpecialNodesInserter.Install (specials, outputVisitor)) { foreach (ICSharpCode.NRefactory.Ast.INode node in blockStatement.Children) { node.AcceptVisitor (outputVisitor, null); // result.AppendLine (outputVisitor.Text); } if (!outputVisitor.OutputFormatter.LastCharacterIsNewLine) outputVisitor.OutputFormatter.NewLine (); inserter.Finish (); result.AppendLine (outputVisitor.Text); } return result.ToString (); } } // Console.WriteLine ("trying to parse expression."); using (ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser (SupportedLanguage.CSharp, new StringReader (input))) { Expression expression = parser.ParseExpression (); hasErrors = parser.Errors.Count != 0; // if (hasErrors) // Console.WriteLine (parser.Errors.ErrorOutput); IList<ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials (); if (parser.Errors.Count == 0) { using (SpecialNodesInserter.Install (specials, outputVisitor)) { expression.AcceptVisitor (outputVisitor, null); } return outputVisitor.Text; } } return input; }
protected override string InternalFormat (PolicyContainer policyParent, string mimeType, string input, int startOffset, int endOffset) { string text = GetFormattedText (policyParent, input); if (startOffset == 0 && endOffset >= input.Length - 1) return text; int newStartOffset = TranslateOffset (input, text, startOffset); int newEndOffset = TranslateOffset (input, text, endOffset); if (newStartOffset < 0 || newEndOffset < 0) return input.Substring (startOffset, System.Math.Max (0, System.Math.Min (endOffset - startOffset, input.Length - startOffset))); return text.Substring (newStartOffset, newEndOffset - newStartOffset); }
public static void SetFormatOptions (CSharpOutputVisitor outputVisitor, PolicyContainer policyParent) { IEnumerable<string> types = DesktopService.GetMimeTypeInheritanceChain (MimeType); TextStylePolicy currentPolicy = policyParent != null ? policyParent.Get<TextStylePolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<TextStylePolicy> (types); CSharpFormattingPolicy codePolicy = policyParent != null ? policyParent.Get<CSharpFormattingPolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<CSharpFormattingPolicy> (types); outputVisitor.Options.IndentationChar = currentPolicy.TabsToSpaces ? ' ' : '\t'; outputVisitor.Options.TabSize = currentPolicy.TabWidth; outputVisitor.Options.IndentSize = currentPolicy.TabWidth; outputVisitor.Options.EolMarker = TextStylePolicy.GetEolMarker(currentPolicy.EolMarker); CodeFormatDescription descr = CSharpFormattingPolicyPanel.CodeFormatDescription; Type optionType = outputVisitor.Options.GetType (); foreach (CodeFormatOption option in descr.AllOptions) { KeyValuePair<string, string> val = descr.GetValue (codePolicy, option); PropertyInfo info = optionType.GetProperty (option.Name); if (info == null) { System.Console.WriteLine ("option : " + option.Name + " not found."); continue; } object cval = null; if (info.PropertyType.IsEnum) { cval = Enum.Parse (info.PropertyType, val.Key); } else if (info.PropertyType == typeof(bool)) { cval = Convert.ToBoolean (val.Key); } else { cval = Convert.ChangeType (val.Key, info.PropertyType); } //System.Console.WriteLine("set " + option.Name + " to " + cval); info.SetValue (outputVisitor.Options, cval, null); } }
public void SetUp() { // Arrange _policyContainer = TestDataFactory.CreateValidPolicyContainer(); _policyContainer .AddPolicy(_policy1) .AddPolicy(_policy2); }
public void Should_return_the_same_results() { // Arrange var context = TestDataFactory.CreateSecurityContext(false); context.Runtime.As<SecurityRuntime>().DefaultResultsCacheLifecycle = Cache.PerHttpSession; var firstPolicy = new IgnorePolicy(); var policyContainer = new PolicyContainer(TestDataFactory.ValidControllerName, TestDataFactory.ValidActionName, TestDataFactory.CreateValidPolicyAppender()); policyContainer.AddPolicy(firstPolicy); // Act var results1 = policyContainer.EnforcePolicies(context); var results2 = policyContainer.EnforcePolicies(context); SecurityCache.ClearCache(Lifecycle.HybridHttpSession); ; var results3 = policyContainer.EnforcePolicies(context); var results4 = policyContainer.EnforcePolicies(context); // Assert Assert.That(results1.Single(), Is.EqualTo(results2.Single())); Assert.That(results3.Single(), Is.EqualTo(results4.Single())); Assert.That(results1.Single(), Is.Not.EqualTo(results3.Single()), "Results should not be equal across sessions."); }