Experiments/AnakiaNet/Anakia/AnakiaTask.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Anakia
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.IO;
  20         using System.Xml;
  21         using Commons.Collections;
  22         using Manoli.Utils.CSharpFormat;
  23         using NAnt.Core;
  24         using NAnt.Core.Attributes;
  25         using NAnt.Core.Types;
  26         using NVelocity;
  27         using NVelocity.App;
  28         using NVelocity.Context;
  29
  30         [TaskName("anakia")]
  31         public class AnakiaTask : Task
  32         {
  33                 private DirectoryInfo targetDir;
  34                 private FileSet sourceFileSet;
  35                 private String navigationFile;
  36                 private String projectFile;
  37                 private String templateFile;
  38                 private String baseGenFolder;
  39
  40                 private VelocityEngine velocity;
  41                 private Template template;
  42                 private Folder root;
  43                 private XmlDocument siteMapDoc;
  44                 private XmlDocument projectDom;
  45
  46                 // Formatters
  47
  48                 private CSharpFormat csharpFormatter = new CSharpFormat();
  49                 private HtmlFormat htmlFormatter = new HtmlFormat();
  50                 private JavaScriptFormat jsFormatter = new JavaScriptFormat();
  51                 private TsqlFormat tsqlFormatter = new TsqlFormat();
  52                 private VisualBasicFormat vbFormatter = new VisualBasicFormat();
  53                 private int orderCount = int.MinValue;
  54
  55                 public AnakiaTask()
  56                 {
  57                 }
  58
  59                 #region Properties
  60
  61                 [TaskAttribute("basefolder")]
  62                 public string BaseGenFolder
  63                 {
  64                         get { return baseGenFolder; }
  65                         set { baseGenFolder = value; }
  66                 }
  67
  68                 [TaskAttribute("navigationfile")]
  69                 public String NavigationFile
  70                 {
  71                         get { return navigationFile; }
  72                         set { navigationFile = value.ToLower(); }
  73                 }
  74
  75                 [TaskAttribute("templatefile")]
  76                 public String TemplateFile
  77                 {
  78                         get { return templateFile; }
  79                         set { templateFile = value; }
  80                 }
  81
  82                 [TaskAttribute("projectfile")]
  83                 public String ProjectFile
  84                 {
  85                         get { return projectFile; }
  86                         set { projectFile = value; }
  87                 }
  88
  89                 [TaskAttribute("targetdir")]
  90                 public DirectoryInfo TargetDir
  91                 {
  92                         get { return targetDir; }
  93                         set { targetDir = value; }
  94                 }
  95
  96                 [BuildElement("source")]
  97                 public FileSet SourceFileSet
  98                 {
  99                         get { return sourceFileSet; }
 100                         set { sourceFileSet = value; }
 101                 }
 102
 103                 #endregion
 104
 105                 #region overrides
 106
 107                 protected override void InitializeTask(XmlNode taskNode)
 108                 {
 109                         base.InitializeTask(taskNode);
 110
 111                         // Initializes NVelocity
 112
 113                         velocity = new VelocityEngine();
 114
 115                         ExtendedProperties props = new ExtendedProperties();
 116                         velocity.Init(props);
 117
 118                         template = velocity.GetTemplate(templateFile);
 119
 120                         // TODO: validate all arguments are present
 121                 }
 122
 123                 protected override void ExecuteTask()
 124                 {
 125                         projectDom = new XmlDocument();
 126                         projectDom.Load(projectFile);
 127
 128                         DirectoryInfo basedir = sourceFileSet.BaseDirectory;
 129
 130                         root = new Folder("castle");
 131
 132                         try
 133                         {
 134                                 ArrayList staticFilesToCopy = new ArrayList();
 135
 136                                 foreach(String fullFileName in sourceFileSet.FileNames)
 137                                 {
 138                                         string lastProcessedFile = null;
 139
 140                                         try
 141                                         {
 142                                                 lastProcessedFile = fullFileName;
 143
 144                                                 String dir = Path.GetDirectoryName(fullFileName);
 145                                                 String fileName = Path.GetFileName(fullFileName);
 146                                                 String nodeName = String.Empty;
 147
 148                                                 Folder folder;
 149                                                 String[] folders;
 150
 151                                                 if (basedir.FullName.ToLower() != dir.ToLower())
 152                                                 {
 153                                                         nodeName = dir.Substring(basedir.FullName.Length + 1);
 154                                                 }
 155
 156                                                 if (IsStaticFile(fullFileName))
 157                                                 {
 158                                                         if (nodeName != String.Empty)
 159                                                         {
 160                                                                 staticFilesToCopy.Add(new FileToCopy(
 161                                                                                         fullFileName, root.Name + "/" + nodeName + "/" + fileName));
 162                                                         }
 163                                                         else
 164                                                         {
 165                                                                 staticFilesToCopy.Add(new FileToCopy(
 166                                                                                         fullFileName, root.Name + "/" + fileName));
 167                                                         }
 168
 169                                                         continue;
 170                                                 }
 171
 172                                                 if (nodeName != String.Empty)
 173                                                 {
 174                                                         folders = nodeName.Split('\\');
 175                                                         folder = GetFolderInstance(folders);
 176                                                 }
 177                                                 else
 178                                                 {
 179                                                         folder = root;
 180                                                 }
 181
 182                                                 XmlDocument doc = new XmlDocument();
 183
 184                                                 doc.Load(fullFileName);
 185
 186                                                 DocumentNode node = new DocumentNode(nodeName, fileName, doc, CreateMeta(doc));
 187                                                 folder.Documents.Add(node);
 188                                         }
 189                                         catch(Exception ex)
 190                                         {
 191                                                 Console.WriteLine("File: {0} \r\n", lastProcessedFile);
 192                                                 Console.WriteLine(ex);
 193                                                 Console.WriteLine("\r\n --------------------------------------------------------");
 194                                         }
 195                                 }
 196
 197                                 siteMapDoc = CreateSiteMap();
 198
 199                                 siteMapDoc.Save(Path.Combine(TargetDir.FullName, "generatedsitemap.xml"));
 200
 201                                 ITreeWalker walker = new BreadthFirstWalker();
 202
 203                                 walker.Walk(root, new Act(AssignNavigationDocToFolders));
 204                                 walker.Walk(root, new Act(CreateBreadCrumb));
 205                                 walker.Walk(root, new Act(FixRelativePaths));
 206                                 walker.Walk(root, new Act(CreateHtml));
 207
 208                                 foreach(FileToCopy file2Copy in staticFilesToCopy)
 209                                 {
 210                                         String dir = Path.GetDirectoryName(file2Copy.TargetFile);
 211
 212                                         EnsureDirExists(dir);
 213
 214                                         String targetFile = targetDir.FullName + "/" + file2Copy.TargetFile;
 215
 216                                         if (File.Exists(targetFile))
 217                                         {
 218                                                 if (File.GetLastWriteTime(targetFile) >= File.GetLastWriteTime(file2Copy.SourceFile))
 219                                                 {
 220                                                         continue;
 221                                                 }
 222
 223                                                 File.Delete(targetFile);
 224                                         }
 225
 226                                         File.Copy(file2Copy.SourceFile, targetFile);
 227                                 }
 228                         }
 229                         catch(Exception ex)
 230                         {
 231                                 Console.WriteLine(ex);
 232                                 Console.Read();
 233                         }
 234                 }
 235
 236                 #endregion
 237
 238                 private void AssignNavigationDocToFolders(DocumentNode node)
 239                 {
 240                         if (node.NodeType != NodeType.Navigation)
 241                         {
 242                                 return;
 243                         }
 244
 245                         node.ParentFolder.NavigationNode = node;
 246                 }
 247
 248                 private bool IsStaticFile(string fileName)
 249                 {
 250                         String ext = Path.GetExtension(fileName);
 251
 252                         return ext != ".xml";
 253                 }
 254
 255                 private DocumentMeta CreateMeta(XmlDocument xmlDocument)
 256                 {
 257                         DocumentMeta meta = new DocumentMeta();
 258
 259                         XmlNode order = xmlDocument.SelectSingleNode("document/@order");
 260
 261                         if (order != null)
 262                         {
 263                                 meta.Order = Convert.ToInt32(order.Value);
 264                         }
 265                         else
 266                         {
 267                                 meta.Order = orderCount++;
 268                         }
 269
 270                         XmlNode properties = xmlDocument.SelectSingleNode("document/properties");
 271
 272                         if (properties != null)
 273                         {
 274                                 foreach(XmlNode child in properties.ChildNodes)
 275                                 {
 276                                         if (child.NodeType != XmlNodeType.Element) continue;
 277
 278                                         if (child.Name == "title")
 279                                         {
 280                                                 meta.Title = child.ChildNodes[0].Value;
 281                                         }
 282                                         else if (child.Name == "categories")
 283                                         {
 284                                                 ArrayList categories = new ArrayList();
 285
 286                                                 foreach(XmlNode cat in child.SelectNodes("category"))
 287                                                 {
 288                                                         categories.Add(cat.ChildNodes[0].Value);
 289                                                 }
 290
 291                                                 meta.Categories = (String[]) categories.ToArray(typeof(String));
 292                                         }
 293                                         else if (child.Name == "audience")
 294                                         {
 295                                                 meta.Audience = child.ChildNodes[0].Value;
 296                                         }
 297                                 }
 298                         }
 299
 300                         return meta;
 301                 }
 302
 303                 private void CreateHtml(DocumentNode node)
 304                 {
 305                         try
 306                         {
 307                                 EnsureDirExists(node.ParentFolder.Path);
 308
 309                                 if (node.NodeType == NodeType.Navigation) return;
 310
 311                                 DirectoryInfo targetFolder = new DirectoryInfo(
 312                                         targetDir.FullName + "/" + node.ParentFolder.Path);
 313
 314                                 FileInfo htmlFileInTarget = new FileInfo(
 315                                         Path.Combine(targetFolder.FullName, node.TargetFilename));
 316
 317                                 if (htmlFileInTarget.Exists)
 318                                 {
 319                                         htmlFileInTarget.Delete();
 320                                 }
 321
 322                                 IContext ctx = CreateContext(node);
 323
 324                                 using(StreamWriter writer = new StreamWriter(htmlFileInTarget.FullName, false))
 325                                 {
 326                                         template.Merge(ctx, writer);
 327                                 }
 328                         }
 329                         catch(Exception ex)
 330                         {
 331                                 throw new Exception("Error generating html for " + node.TargetFilename +
 332                                                     " at " + node.ParentFolder.Path, ex);
 333                         }
 334                 }
 335
 336                 private void EnsureDirExists(String path)
 337                 {
 338                         DirectoryInfo finalDir = new DirectoryInfo(targetDir.FullName + "/" + path);
 339
 340                         if (!finalDir.Exists)
 341                         {
 342                                 finalDir.Create();
 343                         }
 344                 }
 345
 346                 private IContext CreateContext(DocumentNode node)
 347                 {
 348                         VelocityContext context = new VelocityContext();
 349
 350                         context.Put("cs", csharpFormatter);
 351                         context.Put("html", htmlFormatter);
 352                         context.Put("js", jsFormatter);
 353                         context.Put("tsql", tsqlFormatter);
 354                         context.Put("vb", vbFormatter);
 355
 356                         context.Put("basefolder", BaseGenFolder);
 357                         context.Put("breadcrumbs", node.BreadCrumbs);
 358                         context.Put("meta", node.Meta);
 359                         context.Put("doc", node.XmlDoc);
 360                         context.Put("root", node.XmlDoc.DocumentElement);
 361                         context.Put("node", node);
 362                         context.Put("sitemap", siteMapDoc.DocumentElement);
 363                         context.Put("project", projectDom.DocumentElement);
 364                         context.Put("folder", node.ParentFolder);
 365                         context.Put("converter", new SimpleConverter());
 366                         context.Put("helper", new SimpleHelper());
 367                         context.Put("generationdate", DateTime.Now);
 368
 369                         if (node.ParentFolder.NavigationNode != null)
 370                         {
 371                                 context.Put("navigation", node.ParentFolder.NavigationNode.XmlDoc);
 372                         }
 373
 374                         context.Put("navlevel", node.ParentFolder.NavigationLevel);
 375
 376                         String relativePath = String.Empty;
 377
 378                         if (node.ParentFolder.Level == 1)
 379                         {
 380                                 relativePath = ".";
 381                         }
 382                         else
 383                         {
 384                                 for(int i = 0; i < node.ParentFolder.Level - 1; i++)
 385                                 {
 386                                         if (i == 0)
 387                                         {
 388                                                 relativePath += "..";
 389                                         }
 390                                         else
 391                                         {
 392                                                 relativePath += "/..";
 393                                         }
 394                                 }
 395                         }
 396
 397                         context.Put("relativePath", relativePath);
 398
 399                         return context;
 400                 }
 401
 402                 #region BreadCrumb related operations
 403
 404                 private void CreateBreadCrumb(DocumentNode node)
 405                 {
 406                         if (node.NodeType == NodeType.Navigation) return;
 407
 408                         EnsureFolderHasBreadCrumb(node.ParentFolder);
 409
 410                         node.BreadCrumbs.AddRange(node.ParentFolder.BreadCrumbs);
 411
 412                         if (node.NodeType != NodeType.Index)
 413                         {
 414                                 node.BreadCrumbs.Add(new BreadCrumb("", node.Meta.Title));
 415                         }
 416                 }
 417
 418                 private void EnsureFolderHasBreadCrumb(Folder folder)
 419                 {
 420                         if (folder.BreadCrumbs.Count != 0) return;
 421
 422                         if (folder.Parent != null)
 423                         {
 424                                 folder.BreadCrumbs.AddRange(folder.Parent.BreadCrumbs);
 425                         }
 426
 427                         String title = folder.Name;
 428
 429                         if (folder.Documents.IndexNode != null)
 430                         {
 431                                 title = folder.Documents.IndexNode.Meta.Title;
 432                         }
 433
 434                         folder.BreadCrumbs.Add(new BreadCrumb(folder.Path + "/index.html", title));
 435                 }
 436
 437                 #endregion
 438
 439                 private XmlDocument CreateSiteMap()
 440                 {
 441                         ITreeWalker walker = new DepthFirstWalker();
 442                         walker.Walk(root, new Act(CreateNodeSiteMapFragments));
 443
 444                         XmlDocument siteMapDoc = new XmlDocument();
 445                         XmlElement sitemapElem = siteMapDoc.CreateElement("sitemap");
 446                         siteMapDoc.AppendChild(sitemapElem);
 447
 448                         AppendFragments(root, sitemapElem);
 449
 450                         return siteMapDoc;
 451                 }
 452
 453                 private void AppendFragments(Folder folder, XmlElement elem)
 454                 {
 455                         XmlElement el = elem.OwnerDocument.CreateElement(folder.Name);
 456
 457                         elem.AppendChild(el);
 458
 459                         el.SetAttribute("level", folder.Level.ToString());
 460
 461                         if (folder.Documents.IndexNode != null)
 462                         {
 463                                 el.SetAttribute("page", folder.Documents.IndexNode.TargetFilename);
 464                                 el.SetAttribute("title", folder.Documents.IndexNode.Meta.Title);
 465                         }
 466                         else
 467                         {
 468                                 Console.WriteLine("No index.xml found for folder " + folder.Path);
 469                         }
 470
 471                         el.SetAttribute("path", folder.Path);
 472
 473                         foreach(XmlDocumentFragment fragment in folder.SectionFragments)
 474                         {
 475                                 foreach(XmlNode node in fragment.ChildNodes)
 476                                 {
 477                                         el.AppendChild(el.OwnerDocument.ImportNode(node, true));
 478                                 }
 479                         }
 480
 481                         foreach(Folder f in folder.Folders)
 482                         {
 483                                 AppendFragments(f, el);
 484                         }
 485                 }
 486
 487                 private void CreateNodeSiteMapFragments(DocumentNode node)
 488                 {
 489                         if (node.NodeType == NodeType.Navigation) return;
 490
 491                         try
 492                         {
 493                                 XmlDocumentFragment fragment = node.XmlDoc.CreateDocumentFragment();
 494
 495                                 XmlNode parent = fragment;
 496
 497                                 int level = node.ParentFolder.Level;
 498
 499                                 if (node.NodeType == NodeType.Ordinary)
 500                                 {
 501                                         level++;
 502
 503                                         parent = node.XmlDoc.CreateElement(Path.GetFileNameWithoutExtension(node.Filename).Replace(' ', '_'));
 504
 505                                         ((XmlElement) parent).SetAttribute("level", node.ParentFolder.Level.ToString());
 506                                         ((XmlElement) parent).SetAttribute("page", node.TargetFilename);
 507                                         ((XmlElement) parent).SetAttribute("title", node.Meta.Title);
 508                                         ((XmlElement) parent).SetAttribute("issubpage", "true");
 509                                         ((XmlElement) parent).SetAttribute("path", node.ParentFolder.Path);
 510
 511                                         fragment.AppendChild(parent);
 512                                 }
 513
 514                                 foreach(XmlElement section in node.XmlDoc.SelectNodes("document/body/section"))
 515                                 {
 516                                         XmlElement newSection = CreateSectionXmlElement(level, node, section);
 517
 518                                         parent.AppendChild(newSection);
 519
 520                                         foreach(XmlElement secSectionLevel in section.SelectNodes("section"))
 521                                         {
 522                                                 XmlElement newSectionSecLevel = CreateSectionXmlElement(level + 1, node, secSectionLevel);
 523
 524                                                 newSection.AppendChild(newSectionSecLevel);
 525
 526                                                 foreach(XmlElement thirdSectionLevel in secSectionLevel.SelectNodes("section"))
 527                                                 {
 528                                                         XmlElement newSectionThrdLevel = CreateSectionXmlElement(level + 2, node, thirdSectionLevel);
 529
 530                                                         newSectionSecLevel.AppendChild(newSectionThrdLevel);
 531                                                 }
 532                                         }
 533                                 }
 534
 535                                 node.ParentFolder.SectionFragments.Add(fragment);
 536                         }
 537                         catch(Exception ex)
 538                         {
 539                                 throw new Exception("Error creating site map fragments for " + node.Path + "\\" + node.Filename, ex);
 540                         }
 541                 }
 542
 543                 private static XmlElement CreateSectionXmlElement(int level, DocumentNode node, XmlElement section)
 544                 {
 545                         String sectionId = section.GetAttribute("id");
 546                         XmlNode titleElem = section.SelectSingleNode("title");
 547                         String title = titleElem.FirstChild.Value;
 548
 549                         XmlElement newSection = node.XmlDoc.CreateElement("section");
 550
 551                         if (sectionId != String.Empty)
 552                         {
 553                                 newSection.SetAttribute("id", sectionId);
 554                         }
 555                         if (title != null)
 556                         {
 557                                 newSection.SetAttribute("title", title);
 558                         }
 559
 560                         newSection.SetAttribute("page", node.TargetFilename);
 561                         newSection.SetAttribute("level", level.ToString());
 562
 563                         return newSection;
 564                 }
 565
 566                 private void FixRelativePaths(DocumentNode node)
 567                 {
 568                         if (node.XmlDoc == null) return;
 569
 570                         int level = node.ParentFolder.Level;
 571
 572                         XmlNodeList nodes = node.XmlDoc.SelectNodes("//@relative");
 573
 574                         foreach(XmlAttribute xmlNode in nodes)
 575                         {
 576                                 XmlElement elem = xmlNode.OwnerElement;
 577
 578                                 String relative = elem.GetAttribute("relative");
 579
 580                                 if (relative.StartsWith("!"))
 581                                 {
 582                                         relative = relative.Substring(1);
 583                                         elem.SetAttribute("relative", relative);
 584                                 }
 585                                 else
 586                                 {
 587                                         elem.RemoveAttribute("relative");
 588                                 }
 589
 590                                 if (elem.Name.ToLower() == "a")
 591                                 {
 592                                         elem.SetAttribute("href", Relativize(level, relative));
 593                                 }
 594                                 else
 595                                 {
 596                                         elem.SetAttribute("src", Relativize(level, relative));
 597                                 }
 598                         }
 599                 }
 600
 601                 private string Relativize(int level, string relativePath)
 602                 {
 603                         String newPath = "./";
 604
 605                         for(int i = 1; i < level; i++)
 606                         {
 607                                 newPath += "../";
 608                         }
 609
 610                         if (relativePath[0] == '/')
 611                         {
 612                                 return newPath + relativePath.Substring(1);
 613                         }
 614
 615                         return newPath + relativePath;
 616                 }
 617
 618 //              private void PrintStructure(Folder folder, int ident)
 619 //              {
 620 //                      for(int i = 0; i < ident; i++)
 621 //                      {
 622 //                              Console.Write(' ');
 623 //                      }
 624 //
 625 //                      Console.Write(folder.Name);
 626 //                      Console.WriteLine();
 627 //
 628 //                      foreach(Folder f in folder.Folders)
 629 //                      {
 630 //                              PrintStructure(f, ident + 2);
 631 //                      }
 632 //              }
 633 //
 634 //              private void PrintStructure2(Folder folder, int ident)
 635 //              {
 636 //                      for(int i = 0; i < ident; i++)
 637 //                      {
 638 //                              Console.Write(' ');
 639 //                      }
 640 //
 641 //                      Console.Write(folder.Name);
 642 //                      Console.WriteLine();
 643 //
 644 //                      foreach(DocumentNode node in folder.Documents)
 645 //                      {
 646 //                              for(int i = 0; i < ident + 2; i++)
 647 //                              {
 648 //                                      Console.Write(' ');
 649 //                              }
 650 //
 651 //                              Console.Write("- ");
 652 //                              Console.Write(node.Filename);
 653 //                              Console.WriteLine();
 654 //                      }
 655 //
 656 //                      foreach(Folder f in folder.Folders)
 657 //                      {
 658 //                              PrintStructure2(f, ident + 2);
 659 //                      }
 660 //              }
 661
 662                 private Folder GetFolderInstance(string[] folders)
 663                 {
 664                         Folder current = root;
 665
 666                         foreach(String folderName in folders)
 667                         {
 668                                 Folder folder = current.Folders[folderName];
 669
 670                                 if (folder == null)
 671                                 {
 672                                         folder = new Folder(folderName);
 673
 674                                         current.Folders[folderName] = folder;
 675                                 }
 676
 677                                 current = folder;
 678                         }
 679
 680                         return current;
 681                 }
 682         }
 683 }