Experiments/Castle.MonoRail.Generator/Generators/ControllerGenerator.cs

   1 // Copyright 2004-2007 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 Castle.MonoRail.Generator.Generators
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Text;
  20         using System.CodeDom;
  21         using System.Collections;
  22         using System.CodeDom.Compiler;
  23
  24         using Microsoft.CSharp;
  25         using Microsoft.VisualBasic;
  26
  27         /// <summary>
  28         ///
  29         /// </summary>
  30         public class ControllerGenerator : AbstractGenerator, IGenerator
  31         {
  32                 private bool isNVelocity;
  33                 private bool isSmart;
  34                 private bool isCSharp;
  35                 private DirectoryInfo controllersDir;
  36                 private DirectoryInfo viewsDir;
  37                 private DirectoryInfo testsDir;
  38
  39                 public ControllerGenerator()
  40                 {
  41                 }
  42
  43                 #region IGenerator Members
  44
  45                 public bool Accept(String name, IDictionary options, TextWriter output)
  46                 {
  47                         if ("controller".Equals(name))
  48                         {
  49                                 if (options.Values.Count == 1)
  50                                 {
  51                                         output.WriteLine("Creates a controller and it's view skeletons");
  52                                         output.WriteLine("");
  53                                         output.WriteLine("name     : Controller name");
  54                                         output.WriteLine("actions  : Comma separated list of action names");
  55                                         output.WriteLine("ns       : Namespace");
  56                                         output.WriteLine("outdir   : Target directory (must exists)");
  57                                         output.WriteLine("area     : [Optional] Controller area/section");
  58                                         output.WriteLine("smart    : [Optional] Extends SmartDispatcherController (defaults to false)");
  59                                         output.WriteLine("view     : [Optional] aspnet|nvelocity (defaults to nvelocity)");
  60                                         output.WriteLine("lang     : [Optional] c#|vb.net (defaults to c#)");
  61                                         output.WriteLine("");
  62                                         output.WriteLine("Examples:");
  63                                         output.WriteLine("");
  64                                         output.WriteLine(@"> generator controller name:Home actions:Index,About outdir:c:\temp");
  65                                         output.WriteLine("");
  66                                         output.WriteLine(@"> generator controller name:Account ns:My.Project actions:Save,Authenticate smart view:aspnet outdir:c:\temp");
  67                                         output.WriteLine("");
  68                                         output.WriteLine(@"> generator controller name:Home actions:Index,About smart lang:vb.net outdir:c:\temp");
  69                                         output.WriteLine("");
  70                                         output.WriteLine("Remarks:");
  71                                         output.WriteLine("");
  72                                         output.WriteLine("The outdir must point to a structure created by 'generator project'");
  73                                         output.WriteLine("as it relies on the existance of a subdir Controllers and a subdir ");
  74                                         output.WriteLine("Views.");
  75                                         output.WriteLine("Also note that if you're using Windsor integration, you need to add");
  76                                         output.WriteLine("the controller definition to your container:");
  77                                         output.WriteLine("");
  78                                         output.WriteLine(" container.AddComponent( 'mycontroller', typeof(HomeController) ); ");
  79                                         output.WriteLine("");
  80
  81                                         return false;
  82                                 }
  83                                 else if (!options.Contains("actions"))
  84                                 {
  85                                         output.WriteLine("actions must be specified");
  86
  87                                         return false;
  88                                 }
  89                                 else if (!options.Contains("outdir"))
  90                                 {
  91                                         output.WriteLine("outdir must be specified");
  92
  93                                         return false;
  94                                 }
  95                                 else if (!options.Contains("name"))
  96                                 {
  97                                         output.WriteLine("name must be specified");
  98
  99                                         return false;
 100                                 }
 101                                 else
 102                                 {
 103                                         DirectoryInfo info = new DirectoryInfo(options["outdir"] as String);
 104
 105                                         if (!info.Exists)
 106                                         {
 107                                                 // info.Create(); // Is it safe to use it?
 108                                                 output.WriteLine("Error: The specified outdir does not exists.");
 109
 110                                                 return false;
 111                                         }
 112                                 }
 113
 114                                 return true;
 115                         }
 116
 117                         return false;
 118                 }
 119
 120                 public void Execute(IDictionary options, TextWriter output)
 121                 {
 122                         isNVelocity = !(options.Contains("view") && options["view"].Equals("aspnet"));
 123                         isSmart = options.Contains("smart");
 124                         isCSharp = !(options.Contains("lang") && options["lang"].Equals("vb.net"));
 125                         String name = options["name"] as String;
 126                         String area = options["area"] as String;
 127                         String[] actions = (options["actions"] as String).Split(',');
 128
 129                         String ns = options["ns"] as String;
 130                         if (ns == null) ns = "WebApplication";
 131
 132                         output.WriteLine("Creating controller source code...");
 133
 134                         /// Steps to generate a controller
 135
 136                         // 1. Resolve directories (controllers, view, tests)
 137
 138                         output.WriteLine("Resolving directories...");
 139                         ResolveDirs(output, options);
 140
 141                         // 2. Generate code (controllers, view, tests)
 142                         // 3. Write them
 143
 144                         output.WriteLine("Generating source code...");
 145                         GenerateCodeAndWrite(name, area, actions, ns, output);
 146
 147
 148                         output.WriteLine("Done!");
 149                 }
 150
 151                 #endregion
 152
 153                 private void ResolveDirs(TextWriter output, IDictionary options)
 154                 {
 155                         DirectoryInfo outdir = new DirectoryInfo(options["outdir"] as String);
 156
 157                         try
 158                         {
 159                                 controllersDir = new DirectoryInfo(Path.Combine(outdir.FullName, "Controllers"));
 160                                 viewsDir = new DirectoryInfo(Path.Combine(outdir.FullName, "views"));
 161                                 testsDir = new DirectoryInfo(Path.Combine(outdir.FullName, "../" + outdir.Parent + ".Tests"));
 162
 163                                 if (!controllersDir.Exists)
 164                                 {
 165                                         outdir = new DirectoryInfo( Path.Combine(outdir.FullName, outdir.Name) );
 166
 167                                         controllersDir = new DirectoryInfo(Path.Combine(outdir.FullName, "Controllers"));
 168                                         viewsDir = new DirectoryInfo(Path.Combine(outdir.FullName, "views"));
 169                                         testsDir = new DirectoryInfo(Path.Combine(outdir.FullName, "../" + outdir.Parent + ".Tests"));
 170                                 }
 171
 172                                 if (!controllersDir.Exists)
 173                                 {
 174                                         throw new ApplicationException("Could not infer directory structure from the specified 'outdir'");
 175                                 }
 176                         }
 177                         catch(Exception ex)
 178                         {
 179                                 output.WriteLine(ex.Message);
 180                                 throw;
 181                         }
 182                 }
 183
 184                 private void GenerateCodeAndWrite(string name, string area, string[] actions, String ns, TextWriter output)
 185                 {
 186                         CodeDomProvider provider = (isCSharp) ? new CSharpCodeProvider() as CodeDomProvider : new VBCodeProvider() as CodeDomProvider;
 187                         String fileExtension = (isCSharp) ? ".cs" : ".vb";
 188
 189                         GenerateController(provider, fileExtension, ns, name, area, actions, output);
 190
 191                         GenerateViews(name, actions);
 192
 193                         GenerateTestCase(provider, fileExtension, ns, name, area, actions, output);
 194                 }
 195
 196                 private string Quote(string value)
 197                 {
 198                         return String.Format("\"{0}\"", value);
 199                 }
 200
 201                 private void GenerateController(CodeDomProvider provider, string fileExtension, string ns, string name,
 202                         string area, string[] actions, TextWriter output)
 203                 {
 204                         CodeNamespace thisNs = GenerateControllerCode(ns, name, area, actions);
 205
 206                         FileInfo controllerFile = new FileInfo(
 207                                 Path.Combine(controllersDir.FullName, name + fileExtension) );
 208
 209                         if (!controllerFile.Exists)
 210                         {
 211                                 using (StreamWriter sw = new StreamWriter(controllerFile.FullName, false, Encoding.Default))
 212                                 {
 213                                         CodeGeneratorOptions opts = new CodeGeneratorOptions();
 214                                         opts.BracingStyle = "C";
 215 #if DOTNET2
 216                                         provider.GenerateCodeFromNamespace(thisNs, sw, opts);
 217 #else
 218                                         provider.CreateGenerator().GenerateCodeFromNamespace(thisNs, sw, opts);
 219 #endif
 220                                 }
 221                         }
 222                         else
 223                         {
 224                                 output.WriteLine("Skipping {0} as the files exists", controllerFile.FullName);
 225                         }
 226                 }
 227
 228                 private CodeNamespace GenerateControllerCode(string ns, string name, string area, string[] actions)
 229                 {
 230                         CodeNamespace thisNs = new CodeNamespace(ns);
 231                         thisNs.Imports.Add(new CodeNamespaceImport("System"));
 232                         thisNs.Imports.Add(new CodeNamespaceImport("Castle.MonoRail.Framework"));
 233 //                      thisNs.Comments.Add(new CodeCommentStatement("Ignore the above comment or better, delete it"));
 234
 235                         CodeTypeDeclaration controllerType = new CodeTypeDeclaration(name);
 236                         thisNs.Types.Add(controllerType);
 237
 238                         if (area != null)
 239                         {
 240                                 controllerType.CustomAttributes.Add(
 241                                         new CodeAttributeDeclaration("ControllerDetails",
 242                                         new CodeAttributeArgument(new CodeSnippetExpression(Quote(StripControllerFrom(name)))),
 243                                         new CodeAttributeArgument("Area", new CodeSnippetExpression(Quote(area)))) );
 244                         }
 245                         else
 246                         {
 247                                 controllerType.CustomAttributes.Add(
 248                                         new CodeAttributeDeclaration("ControllerDetails",
 249                                         new CodeAttributeArgument(new CodeSnippetExpression(Quote(StripControllerFrom(name))))) );
 250                         }
 251
 252                         if (isSmart)
 253                         {
 254                                 controllerType.BaseTypes.Add( "SmartDispatcherController" );
 255                         }
 256                         else
 257                         {
 258                                 controllerType.BaseTypes.Add( "Controller" );
 259                         }
 260
 261                         foreach(String action in actions)
 262                         {
 263                                 CodeMemberMethod actionMethod = new CodeMemberMethod();
 264                                 actionMethod.Name = action;
 265                                 actionMethod.Attributes = MemberAttributes.Public;
 266
 267                                 controllerType.Members.Add(actionMethod);
 268                         }
 269
 270                         return thisNs;
 271                 }
 272
 273                 private void GenerateViews(String name, String[] actions)
 274                 {
 275                         DirectoryInfo viewSubDir = viewsDir.CreateSubdirectory(StripControllerFrom(name));
 276
 277                         foreach(String action in actions)
 278                         {
 279                                 Hashtable ctx = new Hashtable();
 280                                 ctx.Add("controller", name);
 281                                 ctx.Add("action", action);
 282                                 ctx.Add("dir", viewSubDir.FullName);
 283
 284                                 if (isNVelocity)
 285                                 {
 286                                         WriteTemplateFile( Path.Combine(viewSubDir.FullName, action + ".vm"), ctx, "newview.vm" );
 287                                 }
 288                                 else
 289                                 {
 290                                         WriteTemplateFile( Path.Combine(viewSubDir.FullName, action + ".aspx"), ctx, "newviewaspx.vm" );
 291                                 }
 292                         }
 293                 }
 294
 295                 private void GenerateTestCase(CodeDomProvider provider, string extension, string ns, string name, string area,
 296                         string[] actions, TextWriter output)
 297                 {
 298                         CodeNamespace nsunit = GenerateControllerTestCode(ns, name, area, actions);
 299
 300                         FileInfo controllerFile = new FileInfo(
 301                                 Path.Combine(testsDir.FullName, name + "Tests" + extension) );
 302
 303                         if (!controllerFile.Exists)
 304                         {
 305                                 using (StreamWriter sw = new StreamWriter(controllerFile.FullName, false, Encoding.Default))
 306                                 {
 307                                         CodeGeneratorOptions opts = new CodeGeneratorOptions();
 308                                         opts.BracingStyle = "C";
 309 #if DOTNET2
 310                                         provider.GenerateCodeFromNamespace(nsunit, sw, opts);
 311 #else
 312                                         provider.CreateGenerator().GenerateCodeFromNamespace(nsunit, sw, opts);
 313 #endif
 314                                 }
 315                         }
 316                         else
 317                         {
 318                                 output.WriteLine("Skipping {0} as the files exists", controllerFile.FullName);
 319                         }
 320                 }
 321
 322                 private CodeNamespace GenerateControllerTestCode(string ns, string name, string area, string[] actions)
 323                 {
 324                         String controllerName = StripControllerFrom(name);
 325
 326                         CodeNamespace thisNs = new CodeNamespace(ns + ".Tests");
 327
 328                         thisNs.Imports.Add(new CodeNamespaceImport("System"));
 329                         thisNs.Imports.Add(new CodeNamespaceImport("NUnit.Framework"));
 330                         thisNs.Imports.Add(new CodeNamespaceImport("Castle.MonoRail.TestSupport"));
 331
 332                         CodeTypeDeclaration controllerType = new CodeTypeDeclaration(name + "TestCase");
 333                         thisNs.Types.Add(controllerType);
 334
 335                         controllerType.BaseTypes.Add("AbstractMRTestCase");
 336                         controllerType.CustomAttributes.Add( new CodeAttributeDeclaration("TestFixture") );
 337
 338                         foreach(String action in actions)
 339                         {
 340                                 CodeMemberMethod actionTestMethod = new CodeMemberMethod();
 341                                 actionTestMethod.Name = action;
 342                                 actionTestMethod.Attributes = MemberAttributes.Public;
 343                                 actionTestMethod.CustomAttributes.Add( new CodeAttributeDeclaration("Test") );
 344
 345                                 String url = null;
 346
 347                                 if (area == null || area.Length == 0)
 348                                 {
 349                                         url = String.Format("\"{0}/{1}.rails\"", controllerName, action);
 350                                 }
 351                                 else
 352                                 {
 353                                         url = String.Format("\"{0}/{1}/{2}.rails\"", area, controllerName, action);
 354                                 }
 355
 356                                 String expected = string.Format("\"View for {0} action {1}\"", name, action);
 357
 358                                 CodeMethodInvokeExpression doGetInvoke = new CodeMethodInvokeExpression();
 359                                 doGetInvoke.Method = new CodeMethodReferenceExpression(null, "DoGet");
 360                                 doGetInvoke.Parameters.Add( new CodeSnippetExpression(url) );
 361                                 actionTestMethod.Statements.Add( new CodeExpressionStatement(doGetInvoke) );
 362
 363                                 CodeMethodInvokeExpression assertSuccess = new CodeMethodInvokeExpression();
 364                                 assertSuccess.Method = new CodeMethodReferenceExpression(null, "AssertSuccess");
 365                                 actionTestMethod.Statements.Add( new CodeExpressionStatement(assertSuccess) );
 366
 367                                 CodeMethodInvokeExpression assertReply = new CodeMethodInvokeExpression();
 368                                 assertReply.Method = new CodeMethodReferenceExpression(null, "AssertReplyContains");
 369                                 assertReply.Parameters.Add( new CodeSnippetExpression(expected) );
 370                                 actionTestMethod.Statements.Add( new CodeExpressionStatement(assertReply) );
 371
 372                                 controllerType.Members.Add(actionTestMethod);
 373                         }
 374
 375                         return thisNs;
 376                 }
 377
 378                 private string StripControllerFrom(string value)
 379                 {
 380                         if (value.EndsWith("controller"))
 381                         {
 382                                 return value.Substring(0, value.IndexOf("controller"));
 383                         }
 384                         else if (value.EndsWith("Controller"))
 385                         {
 386                                 return value.Substring(0, value.IndexOf("Controller"));
 387                         }
 388
 389                         return value;
 390                 }
 391         }
 392 }