main/src/addins/AspNetAddIn/MonoDevelop.AspNet.Parser/DocumentReferenceManager.cs

   1 //
   2 // DocumentReferenceManager.cs: Handles web type lookups for ASP.NET documents.
   3 //
   4 // Authors:
   5 //   Michael Hutchinson <mhutchinson@novell.com>
   6 //
   7 // Copyright (C) 2007 Novell, Inc (http://www.novell.com)
   8 //
   9 //
  10 // This source code is licenced under The MIT License:
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.Collections.Generic;
  34 using System.Globalization;
  35
  36 using MonoDevelop.Core;
  37 using MonoDevelop.AspNet.Parser.Dom;
  38 using MonoDevelop.Projects.Text;
  39 using MonoDevelop.Projects.Dom;
  40 using MonoDevelop.Projects.Dom.Output;
  41 using MonoDevelop.Projects.Dom.Parser;
  42 using MonoDevelop.Projects.Gui.Completion;
  43 using MonoDevelop.Ide.Gui;
  44
  45 namespace MonoDevelop.AspNet.Parser
  46 {
  47
  48
  49         public class DocumentReferenceManager
  50         {
  51                 protected List<RegisterDirective> pageRefsList = new List<RegisterDirective> ();
  52                 protected Document doc;
  53
  54                 public DocumentReferenceManager (Document doc)
  55                 {
  56                         this.doc = doc;
  57                         updateList ();
  58                 }
  59
  60                 void updateList ()
  61                 {
  62                         ReferenceVisitor visitor = new ReferenceVisitor (this);
  63                         pageRefsList.Clear ();
  64                         doc.RootNode.AcceptVisit (visitor);
  65                 }
  66
  67                 public string GetTypeName (string tagPrefix, string tagName)
  68                 {
  69                         return GetTypeName (tagPrefix, tagName, null);
  70                 }
  71
  72                 public string GetTypeName (string tagPrefix, string tagName, string htmlTypeAttribute)
  73                 {
  74                         if (tagPrefix == null || tagPrefix.Length < 1)
  75                                 return WebTypeManager.HtmlControlLookup (tagName, htmlTypeAttribute);
  76
  77                         if (0 == string.Compare (tagPrefix, "asp", StringComparison.OrdinalIgnoreCase)) {
  78                                 string systemType = WebTypeManager.SystemTypeNameLookup (tagName, doc.Project);
  79                                 if (!string.IsNullOrEmpty (systemType))
  80                                         return systemType;
  81                         }
  82
  83                         foreach (RegisterDirective directive in pageRefsList) {
  84                                 AssemblyRegisterDirective ard = directive as AssemblyRegisterDirective;
  85                                 if (ard != null && ard.TagPrefix == tagPrefix) {
  86
  87                                         ProjectDom dom = WebTypeManager.ResolveAssembly (doc.Project, ard.Assembly);
  88                                         if (dom == null)
  89                                                 continue;
  90
  91                                         string fullName = WebTypeManager.AssemblyTypeNameLookup (dom, ard.Namespace, tagName);
  92                                         if (fullName != null)
  93                                                 return fullName;
  94                                 }
  95
  96                                 ControlRegisterDirective crd = directive as ControlRegisterDirective;
  97                                 if (crd != null && crd.TagPrefix == tagPrefix) {
  98                                         string fullName =  WebTypeManager.GetUserControlTypeName (doc.Project, doc.FilePath, crd.Src);
  99                                         if (fullName != null)
 100                                                 return fullName;
 101                                 }
 102                         }
 103
 104                         string globalLookup = WebTypeManager.GetRegisteredTypeName (doc.Project,
 105                             System.IO.Path.GetDirectoryName (doc.FilePath), tagPrefix, tagName);
 106
 107                         //returns null if type not found
 108                         return globalLookup;
 109                 }
 110
 111                 public IEnumerable<CompletionData> GetControlCompletionData ()
 112                 {
 113                         return GetControlCompletionData (new DomType ("System.Web.UI.Control"));
 114                 }
 115
 116                 public IEnumerable<CompletionData> GetControlCompletionData (IType baseType)
 117                 {
 118                         bool isSWC = baseType.FullName == "System.Web.UI.Control";
 119
 120                         string aspPrefix = "asp:";
 121                         foreach (IType cls in WebTypeManager.ListSystemControlClasses (baseType, doc.Project))
 122                                 yield return new AspTagCompletionData (aspPrefix, cls);
 123
 124                         foreach (RegisterDirective rd in pageRefsList) {
 125                                 if (!rd.IsValid ())
 126                                         continue;
 127
 128                                 AssemblyRegisterDirective ard = rd as AssemblyRegisterDirective;
 129                                 if (ard != null) {
 130                                         ProjectDom dom = WebTypeManager.ResolveAssembly (doc.Project, ard.Assembly);
 131                                         if (dom == null)
 132                                                 continue;
 133
 134                                         string prefix = ard.TagPrefix + ":";
 135                                         foreach (IType cls in WebTypeManager.ListControlClasses (baseType, dom, ard.Namespace))
 136                                                 yield return new AspTagCompletionData (prefix, cls);
 137                                         continue;
 138                                 }
 139
 140                                 if (!isSWC)
 141                                         continue;
 142
 143                                 ControlRegisterDirective cd = rd as ControlRegisterDirective;
 144                                 if (cd != null) {
 145                                         yield return new CompletionData (string.Concat (cd.TagPrefix, ":", cd.TagName),
 146                                                                          Gtk.Stock.GoForward);
 147                                 }
 148                         }
 149
 150                         //return controls from web.config
 151                         string webDirectory = System.IO.Path.GetDirectoryName (doc.FilePath);
 152                         foreach (CompletionData cd in WebTypeManager.GetRegisteredTypeCompletionData (doc.Project, webDirectory, baseType)) {
 153                                 yield return cd;
 154                         }
 155                 }
 156
 157                 public IType GetControlType (string tagPrefix, string tagName)
 158                 {
 159                         if (String.IsNullOrEmpty (tagPrefix))
 160                                 return null;
 161
 162                         IType type = null;
 163                         if (0 == string.Compare (tagPrefix, "asp", StringComparison.OrdinalIgnoreCase)) {
 164                                 type = WebTypeManager.SystemTypeLookup (tagName, WebTypeManager.GetProjectTargetFramework (doc.Project));
 165                                 if (type != null)
 166                                         return type;
 167                         }
 168
 169                         foreach (RegisterDirective rd in pageRefsList) {
 170                                 if (string.Compare (rd.TagPrefix, tagPrefix, StringComparison.OrdinalIgnoreCase) != 0)
 171                                         continue;
 172
 173                                 AssemblyRegisterDirective ard = rd as AssemblyRegisterDirective;
 174                                 if (ard != null) {
 175                                         string assembly = ard.Assembly;
 176                                         ProjectDom dom = WebTypeManager.ResolveAssembly (doc.Project, ard.Assembly);
 177                                         if (dom == null)
 178                                                 continue;
 179                                         type = WebTypeManager.AssemblyTypeLookup (dom, ard.Namespace, tagName);
 180                                         if (type != null)
 181                                                 return type;
 182                                         continue;
 183                                 }
 184
 185                                 ControlRegisterDirective crd = rd as ControlRegisterDirective;
 186                                 if (crd != null && string.Compare (crd.TagName, tagName, StringComparison.OrdinalIgnoreCase) != 0) {
 187                                         return WebTypeManager.GetUserControlType (doc.Project, crd.Src, System.IO.Path.GetDirectoryName (doc.FilePath));
 188                                 }
 189                         }
 190
 191                         IType globalLookup = WebTypeManager.GetRegisteredType (doc.Project,
 192                             System.IO.Path.GetDirectoryName (doc.FilePath), tagPrefix, tagName);
 193
 194                         //returns null if type not found
 195                         return globalLookup;
 196                 }
 197
 198                 public string GetTagPrefix (IType control)
 199                 {
 200                         if (control.Namespace == "System.Web.UI.WebControls")
 201                                 return "asp";
 202                         else if (control.Namespace == "System.Web.UI.HtmlControls")
 203                                 return string.Empty;
 204
 205                         foreach (RegisterDirective rd in pageRefsList) {
 206                                 AssemblyRegisterDirective ard = rd as AssemblyRegisterDirective;
 207                                 if (ard != null && ard.Namespace == control.Namespace)
 208                                         return ard.TagPrefix;
 209                         }
 210
 211                         string globalPrefix = WebTypeManager.GetControlPrefix (doc.Project, System.IO.Path.GetDirectoryName (doc.FilePath), control);
 212                         if (globalPrefix != null)
 213                                 return globalPrefix;
 214
 215                         return null;
 216                 }
 217
 218                 IEnumerable<RegisterDirective> GetDirectivesForPrefix (string prefix)
 219                 {
 220                         foreach (RegisterDirective rd in pageRefsList)
 221                                 if (string.Equals (rd.TagPrefix, prefix, StringComparison.OrdinalIgnoreCase))
 222                                         yield return rd;
 223                 }
 224
 225                 #region "Refactoring" operations -- things that modify the file
 226
 227                 public string AddAssemblyReferenceToDocument (IType control, string assemblyName)
 228                 {
 229                         return AddAssemblyReferenceToDocument (control, assemblyName, null);
 230                 }
 231
 232                 public string AddAssemblyReferenceToDocument (IType control, string assemblyName, string desiredPrefix)
 233                 {
 234                         string existingPrefix = GetTagPrefix (control);
 235                         if (existingPrefix != null)
 236                                 return existingPrefix;
 237
 238                         //TODO: detect control name conflicts
 239                         string prefix = desiredPrefix;
 240                         if (desiredPrefix == null)
 241                                 prefix = GetPrefix (control);
 242
 243                         System.Reflection.AssemblyName an = MonoDevelop.Core.Runtime.SystemAssemblyService.ParseAssemblyName (assemblyName);
 244
 245                         string directive = string.Format ("{0}<%@ Register TagPrefix=\"{1}\" Namespace=\"{2}\" Assembly=\"{3}\" %>",
 246                             Environment.NewLine, prefix, control.Namespace, an.Name);
 247
 248                         //inset a directive into the document
 249                         InsertDirective (directive);
 250
 251                         return prefix;
 252                 }
 253
 254                 public void AddAssemblyReferenceToProject (string assemblyName, string assemblyLocation)
 255                 {
 256                         //build an reference to the assembly
 257                         MonoDevelop.Projects.ProjectReference pr;
 258                         if (string.IsNullOrEmpty (assemblyLocation)) {
 259                                 pr = new MonoDevelop.Projects.ProjectReference
 260                                         (MonoDevelop.Projects.ReferenceType.Gac, assemblyName);
 261                         } else {
 262                                 pr =  new MonoDevelop.Projects.ProjectReference
 263                                         (MonoDevelop.Projects.ReferenceType.Assembly, assemblyLocation);
 264                         }
 265
 266                         //add the reference if it doesn't match an existing one
 267                         bool match = false;
 268                         foreach (MonoDevelop.Projects.ProjectReference p in doc.Project.References)
 269                                 if (p.Equals (pr))
 270                                         match = true;
 271                         if (!match)
 272                                 doc.Project.References.Add (pr);
 273                 }
 274
 275                 string GetPrefix (IType control)
 276                 {
 277                         //FIXME: make this work
 278                         /*
 279                         foreach (IAttributeSection attSec in control.CompilationUnit.Attributes) {
 280                                 foreach (IAttribute att in attSec.Attributes) {
 281                                         if (att.PositionalArguments != null && att.PositionalArguments.Length == 2
 282                                             && ExprToStr (att.PositionalArguments[0]) == control.Namespace) {
 283                                                 string prefix = ExprToStr (att.PositionalArguments [1]);
 284                                                 if (prefix != null)
 285                                                         return prefix;
 286                                         }
 287
 288                                         if (att.Name == "System.Web.UI.TagPrefixAttribute") {
 289                                                 bool match = false;
 290                                                 foreach (NamedAttributeArgument arg in att.NamedArguments) {
 291                                                         if (arg.Name == "NamespaceName"
 292                                                             && ExprToStr (arg.Expression) == control.Namespace) {
 293                                                                 match = true;
 294                                                                 break;
 295                                                         }
 296                                                 }
 297                                                 foreach (NamedAttributeArgument arg in att.NamedArguments) {
 298                                                         if (arg.Name == "TagPrefix") {
 299                                                                 string prefix = ExprToStr (arg.Expression);
 300                                                                 if (prefix != null)
 301                                                                         return prefix;
 302                                                         }
 303                                                 }
 304                                         }
 305                                 }
 306                         }
 307                         */
 308                         //generate a new prefix base on initials of namespace
 309                         string[] namespaces = control.Namespace.Split ('.');
 310                         char[] charr = new char[namespaces.Length];
 311                         for (int i = 0; i < charr.Length; i++)
 312                                 charr[i] = char.ToLower (namespaces[i][0]);
 313
 314                         //find a variant that doesn't match an existing prefix
 315                         string trialPrefix = new string (charr);
 316                         string trial = trialPrefix;
 317
 318                         for (int trialSuffix = 1; trialSuffix < int.MaxValue; trialSuffix++) {
 319                                 using (IEnumerator<RegisterDirective> en = GetDirectivesForPrefix (trial).GetEnumerator())
 320                                         if (!en.MoveNext ())
 321                                                 return trial;
 322                                 trial = trialPrefix + trialSuffix;
 323                         }
 324                         throw new InvalidOperationException ("Ran out of integer suffixes for tag prefixes");
 325                 }
 326
 327                 string ExprToStr (System.CodeDom.CodeExpression expr)
 328                 {
 329                         System.CodeDom.CodePrimitiveExpression p = expr as System.CodeDom.CodePrimitiveExpression;
 330                         return p != null? p.Value as string : null;
 331                 }
 332
 333                 void InsertDirective (string directive)
 334                 {
 335                         DirectiveNode node = GetPageDirective ();
 336                         if (node == null)
 337                                 return;
 338
 339                         IEditableTextFile textFile =
 340                                 MonoDevelop.DesignerSupport.OpenDocumentFileProvider.Instance.GetEditableTextFile (doc.FilePath);
 341                         if (textFile == null)
 342                                 textFile = new TextFile (doc.FilePath);
 343
 344                         int pos = textFile.GetPositionFromLineColumn (node.Location.EndLine, node.Location.EndColumn);
 345                         textFile.InsertText (pos, directive);
 346                 }
 347
 348                 DirectiveNode GetPageDirective ()
 349                 {
 350                         PageDirectiveVisitor v = new PageDirectiveVisitor ();
 351                         doc.RootNode.AcceptVisit (v);
 352                         return v.DirectiveNode;
 353                 }
 354
 355                 #endregion
 356
 357                 #region directive classes
 358
 359                 protected abstract class RegisterDirective
 360                 {
 361                         private DirectiveNode node;
 362
 363                         public RegisterDirective (DirectiveNode node)
 364                         {
 365                                 this.node = node;
 366                         }
 367
 368                         public DirectiveNode Node {
 369                                 get { return node; }
 370                         }
 371
 372                         public string TagPrefix {
 373                                 get { return (string) node.Attributes ["TagPrefix"]; }
 374                                 set { node.Attributes ["TagPrefix"] = value; }
 375                         }
 376
 377                         public virtual bool IsValid ()
 378                         {
 379                                 if (string.IsNullOrEmpty (TagPrefix))
 380                                         return false;
 381
 382                                 foreach (char c in TagPrefix)
 383                                         if (!Char.IsLetterOrDigit (c))
 384                                                 return false;
 385
 386                                 return true;
 387                         }
 388                 }
 389
 390                 protected class AssemblyRegisterDirective : RegisterDirective
 391                 {
 392                         public AssemblyRegisterDirective (DirectiveNode node)
 393                                 : base (node)
 394                         {
 395                         }
 396
 397                         public string Namespace {
 398                                 get { return (string) Node.Attributes ["Namespace"]; }
 399                                 set { Node.Attributes ["Namespace"] = value; }
 400                         }
 401
 402                         public string Assembly {
 403                                 get { return (string) Node.Attributes ["Assembly"]; }
 404                                 set { Node.Attributes ["Assembly"] = value; }
 405                         }
 406
 407                         public override string ToString ()
 408                         {
 409                                 return String.Format ("<%@ Register {0}=\"{1}\" {2}=\"{3}\" {4}=\"{5}\" %>", "TagPrefix", TagPrefix, "Namespace", Namespace, "Assembly", Assembly);
 410                         }
 411
 412                         public override bool IsValid ()
 413                         {
 414                                 if (string.IsNullOrEmpty (Assembly) || string.IsNullOrEmpty (Namespace) || !base.IsValid ())
 415                                         return false;
 416                                 return true;
 417                         }
 418                 }
 419
 420                 protected class ControlRegisterDirective : RegisterDirective
 421                 {
 422                         public ControlRegisterDirective (DirectiveNode node)
 423                                 : base (node)
 424                         {
 425                         }
 426
 427                         public string TagName {
 428                                 get { return (string) Node.Attributes ["TagName"]; }
 429                                 set { Node.Attributes ["TagName"] = value; }
 430                         }
 431
 432                         public string Src {
 433                                 get { return (string) Node.Attributes ["Src"]; }
 434                                 set { Node.Attributes ["Src"] = value; }
 435                         }
 436
 437                         public override string ToString ()
 438                         {
 439                                 return String.Format ("<%@ Register {0}=\"{1}\" {2}=\"{3}\" {4}=\"{5}\" %>", "TagPrefix", TagPrefix, "TagName", TagName, "Src", Src);
 440                         }
 441
 442                         public override bool IsValid ()
 443                         {
 444                                 if (string.IsNullOrEmpty (TagName) || string.IsNullOrEmpty (Src) || !base.IsValid ())
 445                                         return false;
 446                                 return true;
 447                         }
 448                 }
 449
 450                 private class ReferenceVisitor : Visitor
 451                 {
 452                         DocumentReferenceManager parent;
 453
 454                         public ReferenceVisitor (DocumentReferenceManager parent)
 455                         {
 456                                 this.parent = parent;
 457                         }
 458
 459                         public override void Visit (DirectiveNode node)
 460                         {
 461                                 if ((String.Compare (node.Name, "register", true) != 0) || (node.Attributes ["TagPrefix"] == null))
 462                                         return;
 463
 464                                 if ((node.Attributes ["TagName"] != null) && (node.Attributes ["Src"] != null))
 465                                         parent.pageRefsList.Add (new ControlRegisterDirective (node));
 466                                 else if ((node.Attributes ["Namespace"] != null) && (node.Attributes ["Assembly"] != null))
 467                                         parent.pageRefsList.Add (new AssemblyRegisterDirective (node));
 468                         }
 469                 }
 470
 471                 #endregion classes
 472         }
 473
 474         //lazily loads docs
 475         class AspTagCompletionData : CompletionData
 476         {
 477                 IType cls;
 478
 479                 public AspTagCompletionData (string prefix, IType cls)
 480                         : base (prefix + cls.Name, Gtk.Stock.GoForward)
 481                 {
 482                         this.cls = cls;
 483                 }
 484
 485                 public override string Description {
 486                         get {
 487                                 if (base.Description == null && cls != null)
 488                                         base.Description = DocumentationService.GetCodeCompletionDescription (
 489                                                 cls, AmbienceService.DefaultAmbience);
 490                                 return base.Description;
 491                         }
 492                         set { base.Description = value; }
 493                 }
 494         }
 495 }