/// <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.");
}
