(() => new ContactSelection(textViewAdapter, textView));
+ }
+ }
+}
diff --git a/EditorExtensions/Commands/HTML/SurroundWithTarget.cs b/EditorExtensions/Commands/HTML/SurroundWithTarget.cs
new file mode 100644
index 000000000..9eb449c4d
--- /dev/null
+++ b/EditorExtensions/Commands/HTML/SurroundWithTarget.cs
@@ -0,0 +1,90 @@
+using Microsoft.Html.Core;
+using Microsoft.Html.Editor;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using System;
+
+namespace MadsKristensen.EditorExtensions
+{
+ internal class SurroundWith : CommandTargetBase
+ {
+ private ICompletionBroker _broker;
+ private IWpfTextView _view;
+ private ITextBuffer _buffer;
+
+ public SurroundWith(IVsTextView adapter, IWpfTextView textView, ICompletionBroker broker)
+ : base(adapter, textView, GuidList.guidFormattingCmdSet, PkgCmdIDList.SurroundWith)
+ {
+ _broker = broker;
+ _view = textView;
+ _buffer = textView.TextBuffer;
+ }
+
+ protected override bool Execute(uint commandId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+ {
+ if (_view.Selection.IsEmpty)
+ {
+ return HandleElement();
+ }
+ else
+ {
+ int start = _view.Selection.Start.Position.Position;
+ int end = _view.Selection.End.Position.Position;
+ Update(start, end);
+ return true;
+ }
+
+ return false;
+ }
+
+ private bool HandleElement()
+ {
+ HtmlEditorDocument document = HtmlEditorDocument.FromTextView(_view);
+ var tree = document.HtmlEditorTree;
+
+ int position = _view.Caret.Position.BufferPosition.Position;
+
+ ElementNode tag = null;
+ AttributeNode attr = null;
+
+ tree.GetPositionElement(position, out tag, out attr);
+
+ if (tag != null && (tag.EndTag != null || tag.IsSelfClosing()))
+ {
+ int start = tag.Start;
+ int end = tag.End;
+
+ Update(start, end);
+ return true;
+ }
+
+ return false;
+ }
+
+ private void Update(int start, int end)
+ {
+ EditorExtensionsPackage.DTE.UndoContext.Open("Surround with...");
+
+ using (var edit = _buffer.CreateEdit())
+ {
+ edit.Insert(end, "");
+ edit.Insert(start, "");
+ edit.Apply();
+ }
+
+ SnapshotPoint point = new SnapshotPoint(_buffer.CurrentSnapshot, start + 1);
+
+ _view.Caret.MoveTo(point);
+ _view.Selection.Select(new SnapshotSpan(_buffer.CurrentSnapshot, point, 1), false);
+
+ EditorExtensionsPackage.DTE.UndoContext.Close();
+ }
+
+ protected override bool IsEnabled()
+ {
+ return true;
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/HTML/ZenCodingCommandTarget.cs b/EditorExtensions/Commands/HTML/ZenCodingCommandTarget.cs
new file mode 100644
index 000000000..2831334f1
--- /dev/null
+++ b/EditorExtensions/Commands/HTML/ZenCodingCommandTarget.cs
@@ -0,0 +1,301 @@
+using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Projection;
+using Microsoft.VisualStudio.TextManager.Interop;
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Windows.Threading;
+using ZenCoding;
+
+namespace MadsKristensen.EditorExtensions
+{
+ internal class ZenCoding : CommandTargetBase
+ {
+ private ICompletionBroker _broker;
+ private ITrackingSpan _trackingSpan;
+
+ private static Regex _bracket = new Regex(@"<([a-z0-9]*)\b[^>]*>([^<]*)", RegexOptions.IgnoreCase);
+ private static Regex _quotes = new Regex("(=\"()\")", RegexOptions.IgnoreCase);
+
+ public ZenCoding(IVsTextView adapter, IWpfTextView textView, ICompletionBroker broker)
+ : base(adapter, textView, typeof(VSConstants.VSStd2KCmdID).GUID, 4, 5)
+ {
+ _broker = broker;
+ }
+
+ protected override bool Execute(uint commandId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+ {
+ if (commandId == 4 && !_broker.IsCompletionActive(TextView))
+ {
+ if (WESettings.GetBoolean(WESettings.Keys.EnableHtmlZenCoding))
+ {
+ if (InvokeZenCoding())
+ {
+ return true;
+ }
+ else if (MoveToNextEmptySlot())
+ {
+ return true;
+ }
+ }
+ }
+ else if (commandId == 5 && !_broker.IsCompletionActive(TextView))
+ {
+ if (WESettings.GetBoolean(WESettings.Keys.EnableHtmlZenCoding) && MoveToPrevEmptySlot())
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private bool MoveToNextEmptySlot()
+ {
+ if (_trackingSpan == null)
+ return false;
+
+ int position = TextView.Caret.Position.BufferPosition.Position + 1;
+ Span ts = _trackingSpan.GetSpan(TextView.TextBuffer.CurrentSnapshot);
+
+ if (ts.Contains(position))
+ {
+ Span span = new Span(position, ts.End - position);
+ SetCaret(span, false);
+ return true;
+ }
+
+ return false;
+ }
+
+ private bool MoveToPrevEmptySlot()
+ {
+ if (_trackingSpan == null)
+ return false;
+
+ int position = TextView.Caret.Position.BufferPosition.Position;
+
+ if (position > 0)
+ {
+ Span ts = _trackingSpan.GetSpan(TextView.TextBuffer.CurrentSnapshot);
+
+ if (ts.Contains(position - 1))
+ {
+ Span span = new Span(ts.Start, position - ts.Start - 1);
+ SetCaret(span, true);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private bool InvokeZenCoding()
+ {
+ Span zenSpan = GetText();
+
+ if (zenSpan.Length == 0 || TextView.Selection.SelectedSpans[0].Length > 0 || !IsValidTextBuffer())
+ return false;
+
+ string zenSyntax = TextView.TextBuffer.CurrentSnapshot.GetText(zenSpan);
+
+ Parser parser = new Parser();
+ string result = parser.Parse(zenSyntax, ZenType.HTML);
+
+ if (!string.IsNullOrEmpty(result))
+ {
+ EditorExtensionsPackage.DTE.UndoContext.Open("ZenCoding");
+
+ ITextSelection selection = UpdateTextBuffer(zenSpan, result);
+ Span newSpan = new Span(zenSpan.Start, selection.SelectedSpans[0].Length);
+
+ if (result.Count(c => c == '>') > 2)
+ {
+ _trackingSpan = TextView.TextBuffer.CurrentSnapshot.CreateTrackingSpan(newSpan, SpanTrackingMode.EdgeExclusive);
+ }
+
+ selection.Clear();
+
+ EditorExtensionsPackage.DTE.UndoContext.Close();
+
+ Dispatcher.CurrentDispatcher.BeginInvoke(
+ new Action(() => SetCaret(newSpan, false)), DispatcherPriority.Normal, null);
+
+ return true;
+ }
+
+ return false;
+ }
+
+ private bool IsValidTextBuffer()
+ {
+ var projection = TextView.TextBuffer as IProjectionBuffer;
+
+ if (projection != null)
+ {
+ int position = TextView.Caret.Position.BufferPosition.Position;
+ var snapshotPoint = TextView.Caret.Position.BufferPosition;
+
+ var buffers = projection.SourceBuffers.Where(
+ s =>
+ !s.ContentType.IsOfType("html")
+ && !s.ContentType.IsOfType("htmlx")
+ && !s.ContentType.IsOfType("inert")
+ && !s.ContentType.IsOfType("CSharp")
+ && !s.ContentType.IsOfType("VisualBasic")
+ && !s.ContentType.IsOfType("RoslynCSharp")
+ && !s.ContentType.IsOfType("RoslynVisualBasic"));
+
+
+ foreach (ITextBuffer buffer in buffers)
+ {
+ SnapshotPoint? point = TextView.BufferGraph.MapDownToBuffer(snapshotPoint, PointTrackingMode.Negative, buffer, PositionAffinity.Predecessor);
+
+ if (point.HasValue)
+ {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+
+ //private bool IsValidTextBuffer()
+ //{
+ // IProjectionBuffer projection = _textView.TextBuffer as IProjectionBuffer;
+
+ // if (projection != null)
+ // {
+ // int position = _textView.Caret.Position.BufferPosition.Position;
+ // var buffers = projection.SourceBuffers.Where(s => s.ContentType.IsOfType("css") || s.ContentType.IsOfType("javascript"));
+
+ // foreach (ITextBuffer buffer in buffers)
+ // {
+ // IProjectionSnapshot snapshot = buffer.CurrentSnapshot as IProjectionSnapshot;
+ // bool containsPosition = snapshot.GetSourceSpans().Any(s => s.Contains(position));
+
+ // if (containsPosition)
+ // {
+ // return false;
+ // }
+ // }
+ // }
+
+ // return true;
+ //}
+
+ private bool SetCaret(Span zenSpan, bool isReverse)
+ {
+ string text = TextView.TextBuffer.CurrentSnapshot.GetText();
+ Span quote = FindTabSpan(zenSpan, isReverse, text, _quotes);
+ Span bracket = FindTabSpan(zenSpan, isReverse, text, _bracket);
+
+ if (!isReverse && bracket.Start > 0 && (bracket.Start < quote.Start || quote.Start == 0))
+ {
+ quote = bracket;
+ }
+ else if (isReverse && bracket.Start > 0 && (bracket.Start > quote.Start || quote.Start == 0))
+ {
+ quote = bracket;
+ }
+
+ if (zenSpan.Contains(quote.Start))
+ {
+ MoveTab(quote);
+ return true;
+ }
+ else if (!isReverse)
+ {
+ MoveTab(new Span(zenSpan.End, 0));
+ return true;
+ }
+
+ return false;
+ }
+
+ private void MoveTab(Span quote)
+ {
+ TextView.Caret.MoveTo(new SnapshotPoint(TextView.TextBuffer.CurrentSnapshot, quote.Start));
+ SnapshotSpan span = new SnapshotSpan(TextView.TextBuffer.CurrentSnapshot, quote);
+ TextView.Selection.Select(span, false);
+ }
+
+ private static Span FindTabSpan(Span zenSpan, bool isReverse, string text, Regex regex)
+ {
+ MatchCollection matches = regex.Matches(text);
+
+ if (!isReverse)
+ {
+ foreach (Match match in matches)
+ {
+ Group group = match.Groups[2];
+
+ if (group.Index >= zenSpan.Start)
+ {
+ return new Span(group.Index, group.Length);
+ }
+ }
+ }
+ else
+ {
+ for (int i = matches.Count - 1; i >= 0; i--)
+ {
+ Group group = matches[i].Groups[2];
+
+ if (group.Index < zenSpan.End)
+ {
+ return new Span(group.Index, group.Length);
+ }
+ }
+ }
+
+ return new Span();
+ }
+
+ private ITextSelection UpdateTextBuffer(Span zenSpan, string result)
+ {
+ TextView.TextBuffer.Replace(zenSpan, result);
+
+ SnapshotPoint point = new SnapshotPoint(TextView.TextBuffer.CurrentSnapshot, zenSpan.Start);
+ SnapshotSpan snapshot = new SnapshotSpan(point, result.Length);
+ TextView.Selection.Select(snapshot, false);
+
+ EditorExtensionsPackage.ExecuteCommand("Edit.FormatSelection");
+
+ return TextView.Selection;
+ }
+
+ private Span GetText()
+ {
+ int position = TextView.Caret.Position.BufferPosition.Position;
+
+ if (position >= 0)
+ {
+ var line = TextView.TextBuffer.CurrentSnapshot.GetLineFromPosition(position);
+ string text = line.GetText().TrimEnd();
+
+ if (string.IsNullOrWhiteSpace(text) || text.Length < position - line.Start || text.Length + line.Start > position)
+ return new Span();
+
+ string result = text.Substring(0, position - line.Start).TrimStart();
+
+ if (result.Length > 0 && !text.Contains("<") && !char.IsWhiteSpace(result.Last()))
+ {
+ return new Span(line.Start.Position + text.IndexOf(result), result.Length);
+ }
+ }
+
+ return new Span();
+ }
+
+ protected override bool IsEnabled()
+ {
+ return true;
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/JavaScript/JavaScriptCreationListener.cs b/EditorExtensions/Commands/JavaScript/JavaScriptCreationListener.cs
new file mode 100644
index 000000000..d3f532bf5
--- /dev/null
+++ b/EditorExtensions/Commands/JavaScript/JavaScriptCreationListener.cs
@@ -0,0 +1,42 @@
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Operations;
+using Microsoft.VisualStudio.TextManager.Interop;
+using Microsoft.VisualStudio.Utilities;
+using System.ComponentModel.Composition;
+
+namespace MadsKristensen.EditorExtensions
+{
+ [Export(typeof(IVsTextViewCreationListener))]
+ [ContentType("JavaScript")]
+ [TextViewRole(PredefinedTextViewRoles.Document)]
+ class JavaScriptSortPropertiesViewCreationListener : IVsTextViewCreationListener
+ {
+ [Import, System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal IVsEditorAdaptersFactoryService EditorAdaptersFactoryService { get; set; }
+
+ [Import(typeof(ITextStructureNavigatorSelectorService))]
+ internal ITextStructureNavigatorSelectorService Navigator { get; set; }
+
+ public void VsTextViewCreated(IVsTextView textViewAdapter)
+ {
+ var textView = EditorAdaptersFactoryService.GetWpfTextView(textViewAdapter);
+
+ textView.Properties.GetOrCreateSingletonProperty(() => new MinifySelection(textViewAdapter, textView));
+ textView.Properties.GetOrCreateSingletonProperty(() => new JavaScriptFindReferences(textViewAdapter, textView, Navigator));
+ textView.Properties.GetOrCreateSingletonProperty(() => new CssExtractToFile(textViewAdapter, textView));
+
+ ITextDocument document;
+ textView.TextDataModel.DocumentBuffer.Properties.TryGetProperty(typeof(ITextDocument), out document);
+
+ if (document != null)
+ {
+ JsHintProjectRunner runner = new JsHintProjectRunner(document);
+ textView.Closed += (s, e) => runner.Dispose();
+
+ textView.TextBuffer.Properties.GetOrCreateSingletonProperty(() => runner);
+ }
+ }
+ }
+}
diff --git a/EditorExtensions/Commands/JavaScript/JavaScriptFindReferencesCommandTarget.cs b/EditorExtensions/Commands/JavaScript/JavaScriptFindReferencesCommandTarget.cs
new file mode 100644
index 000000000..80fcac941
--- /dev/null
+++ b/EditorExtensions/Commands/JavaScript/JavaScriptFindReferencesCommandTarget.cs
@@ -0,0 +1,65 @@
+using EnvDTE80;
+using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Operations;
+using Microsoft.VisualStudio.TextManager.Interop;
+using System;
+
+namespace MadsKristensen.EditorExtensions
+{
+ internal class JavaScriptFindReferences : CommandTargetBase
+ {
+ private DTE2 _dte;
+ private ITextStructureNavigator _navigator;
+
+ public JavaScriptFindReferences(IVsTextView adapter, IWpfTextView textView, ITextStructureNavigatorSelectorService navigator)
+ : base(adapter, textView, typeof(VSConstants.VSStd97CmdID).GUID, (uint)VSConstants.VSStd97CmdID.FindReferences)
+ {
+ _navigator = navigator.GetTextStructureNavigator(textView.TextBuffer);
+ _dte = EditorExtensionsPackage.DTE;
+ }
+
+ protected override bool Execute(uint commandId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+ {
+ int position = TextView.Caret.Position.BufferPosition.Position;
+ SnapshotPoint? point = TextView.Caret.Position.Point.GetPoint(TextView.TextBuffer, PositionAffinity.Predecessor);
+
+ if (point.HasValue)
+ {
+ TextExtent wordExtent = _navigator.GetExtentOfWord(point.Value - 1);
+ string wordText = TextView.TextSnapshot.GetText(wordExtent.Span);
+
+ Find2 find = (Find2)EditorExtensionsPackage.DTE.Find;
+ string types = find.FilesOfType;
+ bool matchCase = find.MatchCase;
+ bool matchWord = find.MatchWholeWord;
+
+ find.WaitForFindToComplete = false;
+ find.Action = EnvDTE.vsFindAction.vsFindActionFindAll;
+ find.Backwards = false;
+ find.MatchInHiddenText = true;
+ find.MatchWholeWord = true;
+ find.MatchCase = true;
+ find.PatternSyntax = EnvDTE.vsFindPatternSyntax.vsFindPatternSyntaxLiteral;
+ find.ResultsLocation = EnvDTE.vsFindResultsLocation.vsFindResults1;
+ find.SearchSubfolders = true;
+ find.FilesOfType = "*.js";
+ find.Target = EnvDTE.vsFindTarget.vsFindTargetSolution;
+ find.FindWhat = wordText;
+ find.Execute();
+
+ find.FilesOfType = types;
+ find.MatchCase = matchCase;
+ find.MatchWholeWord = matchWord;
+ }
+
+ return true;
+ }
+
+ protected override bool IsEnabled()
+ {
+ return true;
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/JavaScript/JavaScriptSaveListener.cs b/EditorExtensions/Commands/JavaScript/JavaScriptSaveListener.cs
new file mode 100644
index 000000000..934104ddb
--- /dev/null
+++ b/EditorExtensions/Commands/JavaScript/JavaScriptSaveListener.cs
@@ -0,0 +1,128 @@
+using Microsoft.Ajax.Utilities;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+using System;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MadsKristensen.EditorExtensions
+{
+ [Export(typeof(IWpfTextViewCreationListener))]
+ [ContentType("JavaScript")]
+ [TextViewRole(PredefinedTextViewRoles.Document)]
+ public class JavaScriptSaveListener : IWpfTextViewCreationListener
+ {
+ private ITextDocument _document;
+
+ public void TextViewCreated(IWpfTextView textView)
+ {
+ textView.TextDataModel.DocumentBuffer.Properties.TryGetProperty(typeof(ITextDocument), out _document);
+
+ if (_document != null)
+ {
+ _document.FileActionOccurred += document_FileActionOccurred;
+ }
+ }
+
+ void document_FileActionOccurred(object sender, TextDocumentFileActionEventArgs e)
+ {
+ if (!WESettings.GetBoolean(WESettings.Keys.EnableJsMinification))
+ return;
+
+ ITextDocument document = (ITextDocument)sender;
+
+ if (document.TextBuffer != null && e.FileActionType == FileActionTypes.ContentSavedToDisk && e.FilePath.EndsWith(".js", StringComparison.OrdinalIgnoreCase))
+ {
+ string minFile = e.FilePath.Insert(e.FilePath.Length - 2, "min.");
+ string bundleFile = e.FilePath + ".bundle";
+
+ if (!File.Exists(bundleFile) && File.Exists(minFile) && EditorExtensionsPackage.DTE.Solution.FindProjectItem(minFile) != null)
+ {
+ Task.Run(() =>
+ {
+ Minify(e.FilePath, minFile, false);
+ });
+ }
+ }
+ }
+
+ public static void Minify(string sourceFile, string minFile, bool isBundle)
+ {
+ if (sourceFile.EndsWith(".min.js"))
+ return;
+
+ try
+ {
+ CodeSettings settings = new CodeSettings()
+ {
+ EvalTreatment = EvalTreatment.MakeImmediateSafe,
+ TermSemicolons = true,
+ PreserveImportantComments = WESettings.GetBoolean(WESettings.Keys.KeepImportantComments)
+ };
+
+ if (WESettings.GetBoolean(WESettings.Keys.GenerateJavaScriptSourceMaps))
+ {
+ MinifyFileWithSourceMap(sourceFile, minFile, settings, isBundle);
+ }
+ else
+ {
+ MinifyFile(sourceFile, minFile, settings, isBundle);
+ }
+ }
+ catch (Exception ex)
+ {
+ Logger.Log(ex);
+ }
+ }
+
+ private static void MinifyFileWithSourceMap(string file, string minFile, CodeSettings settings, bool isBundle)
+ {
+ string mapPath = minFile + ".map";
+ ProjectHelpers.CheckOutFileFromSourceControl(mapPath);
+
+ using (TextWriter writer = new StreamWriter(mapPath, false, new UTF8Encoding(false)))
+ using (V3SourceMap sourceMap = new V3SourceMap(writer))
+ {
+ settings.SymbolsMap = sourceMap;
+
+ sourceMap.StartPackage(Path.GetFileName(minFile), Path.GetFileName(mapPath));
+
+ // This fails when debugger is attached. Bug raised with Ron Logan
+ MinifyFile(file, minFile, settings, isBundle);
+
+ sourceMap.EndPackage();
+
+ if (!isBundle)
+ {
+ MarginBase.AddFileToProject(file, mapPath);
+ }
+ }
+ }
+
+ private static void MinifyFile(string file, string minFile, CodeSettings settings, bool isBundle)
+ {
+ Minifier minifier = new Minifier();
+
+ if (!isBundle)
+ {
+ minifier.FileName = Path.GetFileName(file);
+ }
+
+ string content = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
+
+ if (WESettings.GetBoolean(WESettings.Keys.GenerateJavaScriptSourceMaps))
+ {
+ content += Environment.NewLine + "//@ sourceMappingURL=" + Path.GetFileName(minFile) + ".map";
+ }
+
+ ProjectHelpers.CheckOutFileFromSourceControl(minFile);
+ using (StreamWriter writer = new StreamWriter(minFile, false, new UTF8Encoding(true)))
+ {
+ writer.Write(content);
+ }
+ }
+ }
+}
diff --git a/EditorExtensions/Commands/JavaScript/JsHintCompiler.cs b/EditorExtensions/Commands/JavaScript/JsHintCompiler.cs
new file mode 100644
index 000000000..dbc488730
--- /dev/null
+++ b/EditorExtensions/Commands/JavaScript/JsHintCompiler.cs
@@ -0,0 +1,84 @@
+using MadsKristensen.EditorExtensions;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Windows.Threading;
+
+///
+/// Summary description for Lint
+///
+[ComVisible(true)]
+public class JsHintCompiler : ScriptRunnerBase
+{
+ private string _settings;
+ private JsHintOptions _options;
+
+ public JsHintCompiler(Dispatcher dispatcher)
+ : base(dispatcher)
+ { }
+
+ protected override string CreateHtml(string source, string state)
+ {
+ if (_options == null)
+ {
+ _options = new JsHintOptions();
+ _options.LoadSettingsFromStorage();
+ JsHintOptions.Changed += delegate { _options.LoadSettingsFromStorage(); GenerateSettings(); };
+
+ GenerateSettings();
+ }
+
+ source = source
+ .Replace("\\", "\\\\")
+ .Replace("\n", "\\n")
+ .Replace("\r", "\\r")
+ .Replace("'", "\\'");
+
+ string script = ReadResourceFile("MadsKristensen.EditorExtensions.Resources.Scripts.jshint.js") +
+ "JSHINT('" + source + "', {" + _settings + "});" +
+ "window.external.Execute(JSON.stringify(JSHINT.errors), '" + state.Replace("\\", "\\\\") + "')";
+
+ return "";
+ }
+
+ private void GenerateSettings()
+ {
+ Type type = _options.GetType();
+ PropertyInfo[] properties = type.GetProperties();
+ List list = new List();
+
+ foreach (PropertyInfo item in properties)
+ {
+ if (!item.Name.StartsWith("JsHint_"))
+ continue;
+
+ object value = item.GetValue(_options, null);
+ int intValue;
+ bool boolValue;
+
+ if (int.TryParse(value.ToString(), out intValue) && intValue > -1)
+ {
+ list.Add(item.Name.Replace("JsHint_", string.Empty) + ":" + intValue);
+ }
+ else if (bool.TryParse(value.ToString(), out boolValue) && boolValue == true)
+ {
+ list.Add(item.Name.Replace("JsHint_", string.Empty) + ":true");
+ }
+ }
+
+ _settings = string.Join(", ", list);
+ }
+}
+
+public class Result
+{
+ public string id { get; set; }
+ public string raw { get; set; }
+ public string evidence { get; set; }
+ public int line { get; set; }
+ public int character { get; set; }
+ public string a { get; set; }
+ public string b { get; set; }
+ public string reason { get; set; }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/JavaScript/JsHintProjectRunner.cs b/EditorExtensions/Commands/JavaScript/JsHintProjectRunner.cs
new file mode 100644
index 000000000..c542b685f
--- /dev/null
+++ b/EditorExtensions/Commands/JavaScript/JsHintProjectRunner.cs
@@ -0,0 +1,64 @@
+using Microsoft.VisualStudio.Text;
+using System;
+using System.IO;
+using System.Windows.Threading;
+
+namespace MadsKristensen.EditorExtensions
+{
+ internal class JsHintProjectRunner : IDisposable
+ {
+ private ITextDocument _document;
+ private JsHintRunner _runner;
+ private bool _isDisposed;
+
+ public JsHintProjectRunner(ITextDocument document)
+ {
+ _document = document;
+ _document.FileActionOccurred += DocumentSavedHandler;
+ _runner = new JsHintRunner(_document.FilePath);
+
+ if (WESettings.GetBoolean(WESettings.Keys.EnableJsHint))
+ {
+ Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => _runner.RunCompiler()), DispatcherPriority.ApplicationIdle, null);
+ }
+ }
+
+ private void DocumentSavedHandler(object sender, TextDocumentFileActionEventArgs e)
+ {
+ if (!WESettings.GetBoolean(WESettings.Keys.EnableJsHint))
+ return;
+
+ ITextDocument document = (ITextDocument)sender;
+
+ if (document.TextBuffer != null && !_isDisposed && e.FileActionType == FileActionTypes.ContentSavedToDisk)
+ {
+ Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => _runner.RunCompiler()), DispatcherPriority.ApplicationIdle, null);
+ }
+ }
+
+ public static void RunOnAllFilesInProject()
+ {
+ string dir = ProjectHelpers.GetRootFolder();
+
+ if (dir != null && Directory.Exists(dir))
+ {
+ foreach (string file in Directory.GetFiles(dir, "*.js", SearchOption.AllDirectories))
+ {
+ JsHintRunner runner = new JsHintRunner(file);
+ runner.RunCompiler();
+ }
+ }
+ }
+
+ public void Dispose()
+ {
+ if (!_isDisposed)
+ {
+ //_document.Dispose();
+ _runner.Dispose();
+ }
+
+ _isDisposed = true;
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/JavaScript/JsHintRunner.cs b/EditorExtensions/Commands/JavaScript/JsHintRunner.cs
new file mode 100644
index 000000000..bc1e2b9ab
--- /dev/null
+++ b/EditorExtensions/Commands/JavaScript/JsHintRunner.cs
@@ -0,0 +1,246 @@
+using EnvDTE;
+using Microsoft.VisualStudio.Shell;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Web.Script.Serialization;
+using System.Windows.Threading;
+
+namespace MadsKristensen.EditorExtensions
+{
+ internal class JsHintRunner : IDisposable
+ {
+ private ErrorListProvider _provider;
+ private static Dictionary _providers = new Dictionary();
+ private string _fileName;
+ private bool _isDisposed;
+
+ static JsHintRunner()
+ {
+ EditorExtensionsPackage.DTE.Events.SolutionEvents.AfterClosing += SolutionEvents_AfterClosing;
+ }
+
+ static void SolutionEvents_AfterClosing()
+ {
+ Reset();
+ EditorExtensionsPackage.DTE.Events.SolutionEvents.AfterClosing -= SolutionEvents_AfterClosing;
+ }
+
+ public JsHintRunner(string fileName)
+ {
+ _fileName = fileName;
+
+ if (_providers.ContainsKey(fileName))
+ {
+ _provider = _providers[fileName];
+ }
+ else
+ {
+ _provider = new ErrorListProvider(EditorExtensionsPackage.Instance);
+ _providers.Add(fileName, _provider);
+ }
+ }
+
+ public void RunCompiler()
+ {
+ if (!_isDisposed && !ShouldIgnore(_fileName))
+ {
+ EditorExtensionsPackage.DTE.StatusBar.Text = "Web Essentials: Running JSHint...";
+ JsHintCompiler lint = new JsHintCompiler(Dispatcher.CurrentDispatcher);
+
+ System.Threading.Tasks.Task.Run(() =>
+ {
+ using (StreamReader reader = new StreamReader(_fileName))
+ {
+ string content = reader.ReadToEnd();
+
+ lint.Completed += LintCompletedHandler;
+ lint.Compile(content, _fileName);
+ }
+ });
+ }
+ }
+
+ public static void Reset()
+ {
+ foreach (string key in _providers.Keys)
+ {
+ _providers[key].Tasks.Clear();
+ _providers[key].Dispose();
+ }
+
+ _providers.Clear();
+ }
+
+ public static bool ShouldIgnore(string file)
+ {
+ if (!Path.GetExtension(file).Equals(".js", StringComparison.OrdinalIgnoreCase) ||
+ file.EndsWith(".min.js") ||
+ file.EndsWith(".debug.js") ||
+ file.EndsWith(".intellisense.js") ||
+ !File.Exists(file) ||
+ EditorExtensionsPackage.DTE.Solution.FindProjectItem(file) == null)
+ {
+ return true;
+ }
+
+ string name = Path.GetFileName(file);
+
+ foreach (string regex in _ignoreList)
+ {
+ if (Regex.IsMatch(name, regex, RegexOptions.IgnoreCase))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private static List _ignoreList = new List()
+ {
+ @"jquery-([0-9\.]+)\.js",
+ @"jquery-ui-([0-9\.]+)\.js",
+ @"knockout-([0-9\.]+)\.js",
+ @"modernizr-([0-9\.]+)\.js",
+ @"backbone\.js",
+ @"angular\.js",
+ @"amplify\.js",
+ @"dojo\.js",
+ @"ember\.js",
+ @"handlebars-([0-9a-z\.]+)\.js",
+ @"mustache\.js",
+ @"underscore\.js",
+ @"yepnope\.js",
+ @"ext-core\.js",
+ @"highlight\.js",
+ @"history\.js",
+ @"require\.js",
+ @"sammy\.js",
+ @"json2\.js",
+ @"_references\.js",
+ @"MicrosoftAjax([a-z]+)\.js",
+ @"scriptaculous\.js ",
+ @"prototype\.js ",
+ @"qunit-([0-9a-z\.]+)\.js",
+ @"swfobject\.js",
+ @"bootstrap\.js",
+ @"webfont\.js",
+ @"zepto\.js",
+ };
+
+ private void LintCompletedHandler(object sender, CompilerEventArgs e)
+ {
+ using (JsHintCompiler lint = (JsHintCompiler)sender)
+ {
+ if (!_isDisposed)
+ {
+ System.Threading.Tasks.Task.Run(() =>
+ {
+ ReadResult(e);
+ });
+ }
+
+ lint.Completed -= LintCompletedHandler;
+ }
+
+ EditorExtensionsPackage.DTE.StatusBar.Clear();
+ }
+
+ private void ReadResult(CompilerEventArgs e)
+ {
+ try
+ {
+ JavaScriptSerializer serializer = new JavaScriptSerializer();
+ Result[] results = serializer.Deserialize(e.Result);
+
+ _provider.SuspendRefresh();
+ _provider.Tasks.Clear();
+
+ foreach (Result error in results.Where(r => r != null))
+ {
+ ErrorTask task = CreateTask(e.State, error);
+ _provider.Tasks.Add(task);
+ }
+
+ _provider.ResumeRefresh();
+ }
+ catch
+ {
+ Logger.Log("Error reading JSHint result");
+ }
+ }
+
+ private ErrorTask CreateTask(string data, Result error)
+ {
+ ErrorTask task = new ErrorTask()
+ {
+ Line = error.line,
+ Column = error.character,
+ ErrorCategory = GetOutputLocation(),
+ Category = TaskCategory.Html,
+ Document = data,
+ Priority = TaskPriority.Low,
+ Text = GetErrorMessage(error),
+ };
+
+ task.AddHierarchyItem();
+
+ task.Navigate += task_Navigate;
+ return task;
+ }
+
+ private static TaskErrorCategory GetOutputLocation()
+ {
+ var location = (WESettings.Keys.FullErrorLocation)WESettings.GetInt(WESettings.Keys.JsHintErrorLocation);
+
+ if (location == WESettings.Keys.FullErrorLocation.Errors)
+ return TaskErrorCategory.Error;
+
+ if (location == WESettings.Keys.FullErrorLocation.Warnings)
+ return TaskErrorCategory.Warning;
+
+ return TaskErrorCategory.Message;
+ }
+
+ private string GetErrorMessage(Result error)
+ {
+ string raw = error.raw;
+ if (raw == "Missing radix parameter.")
+ raw = "When using the parseInt function, remember to specify the radix parameter. Example: parseInt('3', 10)";
+
+ return "JSHint (r10): " + raw.Replace("{a}", error.a).Replace("{b}", error.b);
+ }
+
+ private void task_Navigate(object sender, EventArgs e)
+ {
+ Task task = sender as Task;
+
+ _provider.Navigate(task, new Guid(EnvDTE.Constants.vsViewKindPrimary));
+
+ if (task.Column > 0)
+ {
+ var doc = (TextDocument)EditorExtensionsPackage.DTE.ActiveDocument.Object("textdocument");
+ doc.Selection.MoveToLineAndOffset(task.Line, task.Column, false);
+ }
+ }
+
+ public void Dispose()
+ {
+ if (!_isDisposed)
+ {
+ if (_providers.ContainsKey(_fileName))
+ {
+ _providers.Remove(_fileName);
+ }
+
+ _provider.Tasks.Clear();
+ _provider.Dispose();
+ }
+
+ _isDisposed = true;
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/JavaScriptSmartIndentCommandTarget.cs b/EditorExtensions/Commands/JavaScriptSmartIndentCommandTarget.cs
new file mode 100644
index 000000000..ce51120cc
--- /dev/null
+++ b/EditorExtensions/Commands/JavaScriptSmartIndentCommandTarget.cs
@@ -0,0 +1,113 @@
+using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.OLE.Interop;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using Microsoft.VisualStudio.Utilities;
+using System;
+using System.ComponentModel.Composition;
+using System.Windows.Forms;
+
+namespace MadsKristensen.EditorExtensions
+{
+ [Export(typeof(IVsTextViewCreationListener))]
+ [ContentType("JavaScript")]
+ [TextViewRole(PredefinedTextViewRoles.Document)]
+ class JavaScriptSmartIndentTextViewCreationListener : IVsTextViewCreationListener
+ {
+ [Import, System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal IVsEditorAdaptersFactoryService EditorAdaptersFactoryService { get; set; }
+
+ [Import]
+ internal ICompletionBroker CompletionBroker { get; set; }
+
+ public void VsTextViewCreated(IVsTextView textViewAdapter)
+ {
+ var textView = EditorAdaptersFactoryService.GetWpfTextView(textViewAdapter);
+ textView.Properties.GetOrCreateSingletonProperty(() => new JavaScriptSmartIndent(textViewAdapter, textView, CompletionBroker));
+ }
+ }
+
+ class JavaScriptSmartIndent : IOleCommandTarget
+ {
+ private ITextView _textView;
+ private IOleCommandTarget _nextCommandTarget;
+ private ICompletionBroker _broker;
+
+ public JavaScriptSmartIndent(IVsTextView adapter, ITextView textView, ICompletionBroker broker)
+ {
+ _textView = textView;
+ _broker = broker;
+ adapter.AddCommandFilter(this, out _nextCommandTarget);
+ }
+
+ public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+ {
+ if (pguidCmdGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
+ {
+ if (nCmdID == 3 && !_broker.IsCompletionActive(_textView))
+ {
+ if (Indent())
+ {
+ return VSConstants.S_OK;
+ }
+ }
+
+ }
+
+ return _nextCommandTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
+ }
+
+ private bool Indent()
+ {
+ int position = _textView.Caret.Position.BufferPosition.Position;
+
+
+ if (position == 0 || position == _textView.TextBuffer.CurrentSnapshot.Length || _textView.Selection.SelectedSpans[0].Length > 0)
+ return false;
+
+ char before = _textView.TextBuffer.CurrentSnapshot.GetText(position - 1, 1)[0];
+ char after = _textView.TextBuffer.CurrentSnapshot.GetText(position, 1)[0];
+
+ if (before == '{' && after == '}')
+ {
+ EditorExtensionsPackage.DTE.UndoContext.Open("Smart indent");
+
+ _textView.TextBuffer.Insert(position, Environment.NewLine + '\t');
+ SnapshotPoint point = new SnapshotPoint(_textView.TextBuffer.CurrentSnapshot, position);
+ _textView.Selection.Select(new SnapshotSpan(point, 4), true);
+
+ EditorExtensionsPackage.ExecuteCommand("Edit.FormatSelection");
+
+ _textView.Selection.Clear();
+ SendKeys.Send("{ENTER}");
+
+ EditorExtensionsPackage.DTE.UndoContext.Close();
+
+ return true;
+ }
+
+ return false;
+ }
+
+ public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
+ {
+ if (pguidCmdGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
+ {
+ for (int i = 0; i < cCmds; i++)
+ {
+ switch (prgCmds[i].cmdID)
+ {
+ case 3:
+ prgCmds[i].cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED);
+ return VSConstants.S_OK;
+ }
+ }
+ }
+
+ return _nextCommandTarget.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText);
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/JsDocRegistry.cs b/EditorExtensions/Commands/JsDocRegistry.cs
new file mode 100644
index 000000000..4792bff06
--- /dev/null
+++ b/EditorExtensions/Commands/JsDocRegistry.cs
@@ -0,0 +1,86 @@
+using Microsoft.Win32;
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace MadsKristensen.EditorExtensions
+{
+ public static class JsDocComments
+ {
+ private static string _fileName = "JsDocComments.js";
+
+ public static void Register()
+ {
+ try
+ {
+ string userPath = GetUserFilePath();
+
+ if (!File.Exists(userPath))
+ {
+ string assembly = Assembly.GetExecutingAssembly().Location;
+ string folder = Path.GetDirectoryName(assembly).ToLowerInvariant();
+ string file = Path.Combine(folder, "resources\\scripts\\JsDocComments.js");
+
+ if (!File.Exists(file))
+ return;
+
+ File.Copy(file, userPath);
+ UpdateRegistry(userPath);
+ }
+ }
+ catch
+ {
+ Logger.Log("Error registering JSDoc comments with Visual Studio");
+ }
+ }
+
+ private static string GetUserFilePath()
+ {
+ string user = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+ string folder = Path.Combine(user, "Web Essentials");
+
+ if (!Directory.Exists(folder))
+ {
+ Directory.CreateDirectory(folder);
+ }
+
+ return Path.Combine(folder, _fileName);
+ }
+
+ private static void UpdateRegistry(string file)
+ {
+ using (RegistryKey key = EditorExtensionsPackage.Instance.UserRegistryRoot.OpenSubKey("JavaScriptLanguageService", true))
+ {
+ if (key != null)
+ {
+ string value = (string)key.GetValue("ReferenceGroups");
+ if (value.Contains(file))
+ return;
+
+ string newValue = value;
+ int index = value.IndexOf(_fileName);
+
+ if (index > -1)
+ {
+ int start = value.LastIndexOf('|', index);
+ int length = index - start + _fileName.Length;
+ string oldPath = value.Substring(start, length);
+ newValue = value.Replace(oldPath, "|" + file);
+ }
+ else
+ {
+ int startWeb = value.IndexOf("Implicit (Web)");
+ int semicolon = value.IndexOf(';', startWeb);
+
+ if (semicolon > -1)
+ {
+ newValue = value.Insert(semicolon, "|" + file);
+ }
+ }
+
+ key.SetValue("ReferenceGroups", newValue);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/LESS/LessCreationListener.cs b/EditorExtensions/Commands/LESS/LessCreationListener.cs
new file mode 100644
index 000000000..91ee8dbae
--- /dev/null
+++ b/EditorExtensions/Commands/LESS/LessCreationListener.cs
@@ -0,0 +1,27 @@
+using Microsoft.Less.Core;
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using Microsoft.VisualStudio.Utilities;
+using Microsoft.Web.Editor;
+using System.ComponentModel.Composition;
+
+namespace MadsKristensen.EditorExtensions
+{
+ [Export(typeof(IVsTextViewCreationListener))]
+ [ContentType(LessContentTypeDefinition.LessContentType)]
+ [TextViewRole(PredefinedTextViewRoles.Document)]
+ class LessViewCreationListener : IVsTextViewCreationListener
+ {
+ [Import, System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal IVsEditorAdaptersFactoryService EditorAdaptersFactoryService { get; set; }
+
+ public void VsTextViewCreated(IVsTextView textViewAdapter)
+ {
+ var textView = EditorAdaptersFactoryService.GetWpfTextView(textViewAdapter);
+
+ textView.Properties.GetOrCreateSingletonProperty(() => new LessExtractVariableCommandTarget(textViewAdapter, textView));
+ textView.Properties.GetOrCreateSingletonProperty(() => new LessExtractMixinCommandTarget(textViewAdapter, textView));
+ }
+ }
+}
diff --git a/EditorExtensions/Commands/LESS/LessExtractMixinCommandTarget.cs b/EditorExtensions/Commands/LESS/LessExtractMixinCommandTarget.cs
new file mode 100644
index 000000000..6a789d619
--- /dev/null
+++ b/EditorExtensions/Commands/LESS/LessExtractMixinCommandTarget.cs
@@ -0,0 +1,61 @@
+using EnvDTE80;
+using Microsoft.CSS.Core;
+using Microsoft.CSS.Editor;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using System;
+
+namespace MadsKristensen.EditorExtensions
+{
+ internal class LessExtractMixinCommandTarget : CommandTargetBase
+ {
+ private DTE2 _dte;
+
+ public LessExtractMixinCommandTarget(IVsTextView adapter, IWpfTextView textView)
+ : base(adapter, textView, GuidList.guidExtractCmdSet, PkgCmdIDList.ExtractMixin)
+ {
+ _dte = EditorExtensionsPackage.DTE;
+ }
+
+ protected override bool Execute(uint commandId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+ {
+ if (TextView == null)
+ return false;
+
+ CssEditorDocument document = CssEditorDocument.FromTextBuffer(TextView.TextBuffer);
+
+ int position = TextView.Caret.Position.BufferPosition.Position;
+ ParseItem item = document.Tree.StyleSheet.ItemBeforePosition(position);
+
+ ParseItem rule = LessExtractVariableCommandTarget.FindParent(item);
+ int mixinStart = rule.Start;
+ string name = Microsoft.VisualBasic.Interaction.InputBox("Name of the Mixin", "Web Essentials");
+
+ if (!string.IsNullOrEmpty(name))
+ {
+ EditorExtensionsPackage.DTE.UndoContext.Open("Extract to mixin");
+
+ var selection = TextView.Selection.SelectedSpans[0];
+ string text = selection.GetText();
+ TextView.TextBuffer.Replace(selection.Span, "." + name + "();");
+ TextView.TextBuffer.Insert(rule.Start, "." + name + "() {" + Environment.NewLine + text + Environment.NewLine + "}" + Environment.NewLine + Environment.NewLine);
+
+ TextView.Selection.Select(new SnapshotSpan(TextView.TextBuffer.CurrentSnapshot, mixinStart, 1), false);
+ EditorExtensionsPackage.ExecuteCommand("Edit.FormatSelection");
+ TextView.Selection.Clear();
+
+ EditorExtensionsPackage.DTE.UndoContext.Close();
+
+ return true;
+ }
+
+ return false;
+ }
+
+ protected override bool IsEnabled()
+ {
+ return TextView.Selection.SelectedSpans[0].Length > 0;
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/LESS/LessExtractVariableCommandTarget.cs b/EditorExtensions/Commands/LESS/LessExtractVariableCommandTarget.cs
new file mode 100644
index 000000000..6a7ee5c38
--- /dev/null
+++ b/EditorExtensions/Commands/LESS/LessExtractVariableCommandTarget.cs
@@ -0,0 +1,73 @@
+using EnvDTE80;
+using Microsoft.CSS.Core;
+using Microsoft.CSS.Editor;
+using Microsoft.Less.Core;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using System;
+
+namespace MadsKristensen.EditorExtensions
+{
+ internal class LessExtractVariableCommandTarget : CommandTargetBase
+ {
+ private DTE2 _dte;
+
+ public LessExtractVariableCommandTarget(IVsTextView adapter, IWpfTextView textView)
+ : base(adapter, textView, GuidList.guidExtractCmdSet, PkgCmdIDList.ExtractVariable)
+ {
+ _dte = EditorExtensionsPackage.DTE;
+ }
+
+ protected override bool Execute(uint commandId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+ {
+ if (TextView == null)
+ return false;
+
+ CssEditorDocument document = CssEditorDocument.FromTextBuffer(TextView.TextBuffer);
+
+ int position = TextView.Caret.Position.BufferPosition.Position;
+ ParseItem item = document.Tree.StyleSheet.ItemBeforePosition(position);
+
+ ParseItem rule = FindParent(item);
+ string text = item.Text;
+ string name = Microsoft.VisualBasic.Interaction.InputBox("Name of the variable", "Web Essentials");
+
+ if (!string.IsNullOrEmpty(name))
+ {
+ EditorExtensionsPackage.DTE.UndoContext.Open("Extract to variable");
+
+ Span span = TextView.Selection.SelectedSpans[0].Span;
+ TextView.TextBuffer.Replace(span, "@" + name);
+ TextView.TextBuffer.Insert(rule.Start, "@" + name + ": " + text + ";" + Environment.NewLine + Environment.NewLine);
+
+ EditorExtensionsPackage.DTE.UndoContext.Close();
+
+ return true;
+ }
+
+ return false;
+ }
+
+ public static ParseItem FindParent(ParseItem item)
+ {
+ ParseItem parent = item.Parent;
+
+ while (true)
+ {
+ if (parent.Parent == null || parent.Parent is LessStyleSheet || parent.Parent is AtDirective)
+ break;
+
+ parent = parent.Parent;
+ }
+
+ return parent;
+ }
+
+ protected override bool IsEnabled()
+ {
+ var span = TextView.Selection.SelectedSpans[0];
+ return span.Length > 0 && !span.GetText().Contains("\r");
+ }
+ }
+}
\ No newline at end of file
diff --git a/EditorExtensions/Commands/MoveRuleCommandTarget.cs b/EditorExtensions/Commands/MoveRuleCommandTarget.cs
new file mode 100644
index 000000000..981d41a40
--- /dev/null
+++ b/EditorExtensions/Commands/MoveRuleCommandTarget.cs
@@ -0,0 +1,382 @@
+using Microsoft.CSS.Core;
+using Microsoft.CSS.Editor;
+using Microsoft.CSS.Editor.Intellisense;
+using Microsoft.CSS.Editor.Schemas;
+using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.OLE.Interop;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using Microsoft.VisualStudio.Utilities;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Xml;
+
+namespace MadsKristensen.EditorExtensions
+{
+ [Export(typeof(IVsTextViewCreationListener))]
+ [ContentType(Microsoft.Web.Editor.CssContentTypeDefinition.CssContentType)]
+ [TextViewRole(PredefinedTextViewRoles.Document)]
+ class MoveRuleTextViewCreationListener : IVsTextViewCreationListener
+ {
+ [Import, System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal IVsEditorAdaptersFactoryService EditorAdaptersFactoryService { get; set; }
+
+ public void VsTextViewCreated(IVsTextView textViewAdapter)
+ {
+ var textView = EditorAdaptersFactoryService.GetWpfTextView(textViewAdapter);
+ textView.Properties.GetOrCreateSingletonProperty(() => new MoveRuleTarget(textViewAdapter, textView));
+ }
+ }
+
+ class MoveRuleTarget : IOleCommandTarget
+ {
+ private ITextView _textView;
+ private IOleCommandTarget _nextCommandTarget;
+ private CssTree _tree;
+
+ public MoveRuleTarget(IVsTextView adapter, ITextView textView)
+ {
+ this._textView = textView;
+ adapter.AddCommandFilter(this, out _nextCommandTarget);
+ }
+
+ public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
+ {
+ if (pguidCmdGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
+ {
+ switch (nCmdID)
+ {
+ case 2400:
+ if (Move(Direction.Down))
+ return VSConstants.S_OK;
+ break;
+
+ case 2401:
+ if (Move(Direction.Up))
+ return VSConstants.S_OK;
+ break;
+ }
+ }
+
+ return _nextCommandTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
+ }
+
+ private enum Direction
+ {
+ Up,
+ Down
+ }
+
+ private bool Move(Direction direction)
+ {
+ if (!EnsureInitialized())
+ return false;
+
+ int position = _textView.Caret.Position.BufferPosition.Position;
+
+ ParseItem item = _tree.StyleSheet.ItemBeforePosition(position);
+
+ Declaration dec = item.FindType();
+ if (dec != null)
+ {
+ return HandleDeclaration(direction, dec);
+ }
+
+ Selector selector = item.FindType();
+ if (selector != null)
+ {
+ return HandleSelector(direction, selector);
+ }
+
+ return false;
+ }
+
+ private bool HandleDeclaration(Direction direction, Declaration declaration)
+ {
+ RuleBlock rule = declaration.FindType();
+ if (rule == null || rule.Text.IndexOfAny(new[] { '\r', '\n' }) == -1 || (direction == Direction.Up && rule.Declarations.First() == declaration) || (direction == Direction.Down && rule.Declarations.Last() == declaration))
+ return false;
+
+ Declaration sibling = null;
+ string text = null;
+
+ if (direction == Direction.Up)
+ {
+ sibling = rule.Declarations.ElementAt(rule.Declarations.IndexOf(declaration) - 1);
+ text = declaration.Text + sibling.Text;
+ }
+ else
+ {
+ sibling = rule.Declarations.ElementAt(rule.Declarations.IndexOf(declaration) + 1);
+ text = sibling.Text + declaration.Text;
+ }
+
+ EditorExtensionsPackage.DTE.UndoContext.Open("Move CSS declaration");
+
+ using (ITextEdit edit = _textView.TextBuffer.CreateEdit())
+ {
+ int start = Math.Min(declaration.Start, sibling.Start);
+ int end = Math.Max(declaration.AfterEnd, sibling.AfterEnd);
+ edit.Replace(start, end - start, text);
+ edit.Apply();
+
+ if (direction == Direction.Up)
+ _textView.Caret.MoveTo(new SnapshotPoint(_textView.TextBuffer.CurrentSnapshot, sibling.Start + 1));
+
+ EditorExtensionsPackage.DTE.ExecuteCommand("Edit.FormatSelection");
+ EditorExtensionsPackage.DTE.UndoContext.Close();
+ }
+
+ return true;
+ }
+
+ private bool HandleSelector(Direction direction, Selector selector)
+ {
+ //new WriteBrowserXml().Parse();
+ RuleSet rule = selector.FindType();
+ if (rule == null)
+ return false;
+
+ if (direction == Direction.Up)
+ {
+ rule = rule.PreviousSibling as RuleSet;
+ if (rule == null)
+ return false;
+ }
+
+ EditorExtensionsPackage.DTE.UndoContext.Open("Move CSS rule");
+
+ using (ITextEdit edit = _textView.TextBuffer.CreateEdit())
+ {
+ int position = SwapItemWithNextSibling(rule, edit);
+ if (position > -1)
+ {
+ if (direction == Direction.Down)
+ _textView.Caret.MoveTo(new SnapshotPoint(_textView.TextBuffer.CurrentSnapshot, position + 1));
+ else
+ _textView.Caret.MoveTo(new SnapshotPoint(_textView.TextBuffer.CurrentSnapshot, rule.Start + 1));
+
+ // TODO: Format both rules
+ EditorExtensionsPackage.DTE.ExecuteCommand("Edit.FormatSelection");
+ }
+
+ EditorExtensionsPackage.DTE.UndoContext.Close();
+ }
+
+ return true;
+ }
+
+ private int SwapItemWithNextSibling(ParseItem item, ITextEdit edit)
+ {
+ RuleSet next = item.NextSibling as RuleSet;
+ if (next == null)
+ return -1;
+
+ ITextSnapshot snapshot = _textView.TextBuffer.CurrentSnapshot;
+ string whitespace = snapshot.GetText(item.AfterEnd, next.Start - item.AfterEnd);
+ string text = next.Text + whitespace + item.Text;
+
+ edit.Replace(item.Start, next.AfterEnd - item.Start, text);
+ edit.Apply();
+
+ return item.Start + next.Length + whitespace.Length;
+ }
+
+ public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
+ {
+ if (pguidCmdGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
+ {
+ for (int i = 0; i < cCmds; i++)
+ {
+ switch (prgCmds[i].cmdID)
+ {
+ case 2401: // Up
+ case 2400: // Down
+ prgCmds[i].cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED);
+ return VSConstants.S_OK;
+ }
+ }
+ }
+
+ return _nextCommandTarget.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText);
+ }
+
+ public bool EnsureInitialized()
+ {
+ if (_tree == null && Microsoft.Web.Editor.WebEditor.Host != null)
+ {
+ try
+ {
+ CssEditorDocument document = CssEditorDocument.FromTextBuffer(_textView.TextBuffer);
+ _tree = document.Tree;
+ }
+ catch (ArgumentNullException)
+ {
+ }
+ }
+
+ return _tree != null;
+ }
+ }
+
+ public class WriteBrowserXml
+ {
+ private const string _fileName = @"C:\Users\madsk\Documents\visual studio 2012\Projects\RealWorldValidator\RealWorldValidator\App_Data\browsers.xml";
+
+ public void Parse()
+ {
+ ICssSchemaInstance root = CssSchemaManager.SchemaManager.GetSchemaRoot(null);
+ IEnumerable schemas = GetAllSchemas(root);
+ using (XmlWriter writer = XmlWriter.Create(_fileName))
+ {
+ writer.WriteStartElement("css");
+
+ // @-Directives
+ List directives = new List(root.AtDirectives);
+ directives.AddRange(schemas.SelectMany(s => s.AtDirectives));
+ directives = RemoveDuplicates(directives);
+
+ writer.WriteStartElement("atDirectives");
+ WriteSection(writer, directives);
+ //WriteSection(writer, root.AtDirectives);
+ //foreach (var schema in schemas)
+ // WriteSection(writer, schema.AtDirectives);
+ writer.WriteEndElement();
+
+ // Pseudos
+ List pseudos = new List(root.PseudoClassesAndElements);
+ pseudos.AddRange(schemas.SelectMany(s => s.PseudoClassesAndElements));
+ pseudos = RemoveDuplicates(pseudos);
+
+ writer.WriteStartElement("pseudoClasses");
+ WriteSection(writer, pseudos.Where(p => p.DisplayText[1] != ':'));
+ writer.WriteEndElement();
+
+ writer.WriteStartElement("pseudoElements");
+ WriteSection(writer, pseudos.Where(p => p.DisplayText[1] == ':'));
+ writer.WriteEndElement();
+
+ // Properties
+ List properties = new List(root.Properties);
+ properties.AddRange(schemas.SelectMany(s => s.Properties));
+ properties = RemoveDuplicates(properties);
+
+ writer.WriteStartElement("properties");
+ WriteProperties(writer, properties, root);
+ //WriteProperties(writer, root.Properties, root);
+ //foreach (var schema in schemas)
+ // WriteProperties(writer, schema.Properties, schema);
+ writer.WriteEndElement();
+
+ writer.WriteEndElement();
+ }
+ }
+
+ private List RemoveDuplicates(List list)
+ {
+ for (int i = list.Count() - 1; i > -1; i--)
+ {
+ if (list.Count(p => p.DisplayText == list.ElementAt(i).DisplayText) > 1)
+ list.RemoveAt(i);
+ }
+
+ return list;
+ }
+
+ string[] vs = new[] { "@-we-palette", "@unspecified", "@global", "@specific" };
+
+ private IEnumerable GetAllSchemas(ICssSchemaInstance rootSchema)
+ {
+ foreach (ICssCompletionListEntry directive in rootSchema.AtDirectives)
+ {
+ if (vs.Contains(directive.DisplayText))
+ continue;
+
+ ICssSchemaInstance schema = rootSchema.GetAtDirectiveSchemaInstance(directive.DisplayText);
+ if (schema != null && schema.Properties.Count() != rootSchema.Properties.Count())
+ yield return schema;
+ }
+ }
+
+ private void WriteSection(XmlWriter writer, IEnumerable entries)
+ {
+ foreach (ICssCompletionListEntry entry in entries.OrderBy(e => e.DisplayText))
+ {
+ writer.WriteStartElement("entry");
+ writer.WriteAttributeString("name", entry.DisplayText);
+ writer.WriteAttributeString("version", entry.GetAttribute("version"));
+ WriteBrowserSupport(writer, entry);
+
+ if (!string.IsNullOrEmpty(entry.GetAttribute("standard-reference")))
+ writer.WriteAttributeString("ref", entry.GetAttribute("standard-reference"));
+
+ if (!string.IsNullOrEmpty(entry.GetAttribute("syntax")))
+ writer.WriteAttributeString("syntax", entry.GetAttribute("syntax"));
+
+ if (!string.IsNullOrEmpty(entry.GetAttribute("description")))
+ writer.WriteElementString("desc", entry.GetAttribute("description"));
+
+ writer.WriteEndElement();
+ }
+ }
+
+ private void WriteProperties(XmlWriter writer, IEnumerable