MonoRail/Castle.MonoRail.Framework/Configuration/JSGeneratorConfiguration.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 Castle.MonoRail.Framework.Configuration
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19
  20         /// <summary>
  21         /// Pendent
  22         /// </summary>
  23         public class JSGeneratorConfiguration
  24         {
  25                 private readonly List<LibraryConfiguration> libraries = new List<LibraryConfiguration>();
  26                 private LibraryConfiguration defaultLibrary;
  27
  28                 /// <summary>
  29                 /// Adds the library.
  30                 /// </summary>
  31                 /// <param name="name">The name.</param>
  32                 /// <param name="mainGenerator">The main generator.</param>
  33                 /// <returns></returns>
  34                 public LibraryConfigurationBuilder AddLibrary(string name, Type mainGenerator)
  35                 {
  36                         LibraryConfiguration config = new LibraryConfiguration(name, mainGenerator);
  37                         libraries.Add(config);
  38
  39                         return new LibraryConfigurationBuilder(this, config);
  40                 }
  41
  42                 /// <summary>
  43                 /// Gets the libraries configuration.
  44                 /// </summary>
  45                 /// <value>The libraries.</value>
  46                 public List<LibraryConfiguration> Libraries
  47                 {
  48                         get { return libraries; }
  49                 }
  50
  51                 /// <summary>
  52                 /// Gets the default library configuration.
  53                 /// </summary>
  54                 /// <value>The default library.</value>
  55                 public LibraryConfiguration DefaultLibrary
  56                 {
  57                         get { return defaultLibrary; }
  58                 }
  59
  60                 /// <summary>
  61                 /// Configures a JS generator for specific JS library
  62                 /// </summary>
  63                 public class LibraryConfigurationBuilder
  64                 {
  65                         private readonly JSGeneratorConfiguration configuration;
  66                         private readonly LibraryConfiguration config;
  67                         private readonly ElementGeneratorConfigBuilder elementConfig;
  68
  69                         /// <summary>
  70                         /// Initializes a new instance of the <see cref="LibraryConfigurationBuilder"/> class.
  71                         /// </summary>
  72                         /// <param name="configuration">The configuration.</param>
  73                         /// <param name="config">The config.</param>
  74                         public LibraryConfigurationBuilder(JSGeneratorConfiguration configuration, LibraryConfiguration config)
  75                         {
  76                                 this.configuration = configuration;
  77                                 this.config = config;
  78                                 elementConfig = new ElementGeneratorConfigBuilder(this);
  79                         }
  80
  81                         /// <summary>
  82                         /// Adds an extension.
  83                         /// </summary>
  84                         /// <param name="extensionType">Type of the extension.</param>
  85                         /// <returns></returns>
  86                         public LibraryConfigurationBuilder AddExtension(Type extensionType)
  87                         {
  88                                 config.MainExtensions.Add(extensionType);
  89                                 return this;
  90                         }
  91
  92                         /// <summary>
  93                         /// Sets the browser validator provider for the library
  94                         /// </summary>
  95                         /// <param name="browserValidatorProvider">The browser validator provider.</param>
  96                         public LibraryConfigurationBuilder BrowserValidatorIs(Type browserValidatorProvider)
  97                         {
  98                                 config.BrowserValidatorProvider = browserValidatorProvider;
  99                                 return this;
 100                         }
 101
 102                         /// <summary>
 103                         /// Gets the element generator.
 104                         /// </summary>
 105                         /// <value>The element generator.</value>
 106                         public ElementGeneratorConfigBuilder ElementGenerator
 107                         {
 108                                 get { return elementConfig; }
 109                         }
 110
 111                         /// <summary>
 112                         /// Sets this JS library as the default one.
 113                         /// </summary>
 114                         public void SetAsDefault()
 115                         {
 116                                 configuration.defaultLibrary = config;
 117                         }
 118
 119                         /// <summary>
 120                         /// Configures the element section of the library config
 121                         /// </summary>
 122                         public class ElementGeneratorConfigBuilder
 123                         {
 124                                 private readonly LibraryConfigurationBuilder builder;
 125
 126                                 /// <summary>
 127                                 /// Initializes a new instance of the <see cref="ElementGeneratorConfigBuilder"/> class.
 128                                 /// </summary>
 129                                 /// <param name="builder">The builder.</param>
 130                                 public ElementGeneratorConfigBuilder(LibraryConfigurationBuilder builder)
 131                                 {
 132                                         this.builder = builder;
 133                                 }
 134
 135                                 /// <summary>
 136                                 /// Adds an element only extension.
 137                                 /// </summary>
 138                                 /// <param name="extensionType">Type of the extension.</param>
 139                                 /// <returns></returns>
 140                                 public ElementGeneratorConfigBuilder AddExtension(Type extensionType)
 141                                 {
 142                                         builder.config.ElementExtension.Add(extensionType);
 143                                         return this;
 144                                 }
 145
 146                                 /// <summary>
 147                                 /// Go back to the main library configuration
 148                                 /// </summary>
 149                                 public LibraryConfigurationBuilder Done
 150                                 {
 151                                         get { return builder; }
 152                                 }
 153                         }
 154                 }
 155         }
 156
 157         /// <summary>
 158         /// Configuration for JS generation for an specific JS library
 159         /// </summary>
 160         public class LibraryConfiguration
 161         {
 162                 private readonly string name;
 163                 private readonly Type mainGenerator;
 164                 private readonly List<Type> mainExtensions = new List<Type>();
 165                 private readonly List<Type> elementExtension = new List<Type>();
 166                 private Type browserValidatorProvider;
 167
 168                 /// <summary>
 169                 /// Initializes a new instance of the <see cref="LibraryConfiguration"/> class.
 170                 /// </summary>
 171                 /// <param name="name">The name.</param>
 172                 /// <param name="mainGenerator">The main generator.</param>
 173                 public LibraryConfiguration(string name, Type mainGenerator)
 174                 {
 175                         if (string.IsNullOrEmpty(name))
 176                         {
 177                                 throw new ArgumentNullException("name");
 178                         }
 179                         if (mainGenerator == null)
 180                         {
 181                                 throw new ArgumentNullException("mainGenerator");
 182                         }
 183
 184                         this.name = name;
 185                         this.mainGenerator = mainGenerator;
 186                 }
 187
 188                 /// <summary>
 189                 /// Gets the name.
 190                 /// </summary>
 191                 /// <value>The name.</value>
 192                 public string Name
 193                 {
 194                         get { return name; }
 195                 }
 196
 197                 /// <summary>
 198                 /// Gets the main generator.
 199                 /// </summary>
 200                 /// <value>The main generator.</value>
 201                 public Type MainGenerator
 202                 {
 203                         get { return mainGenerator; }
 204                 }
 205
 206                 /// <summary>
 207                 /// Gets the main extensions.
 208                 /// </summary>
 209                 /// <value>The main extensions.</value>
 210                 public List<Type> MainExtensions
 211                 {
 212                         get { return mainExtensions; }
 213                 }
 214
 215                 /// <summary>
 216                 /// Gets the element extension.
 217                 /// </summary>
 218                 /// <value>The element extension.</value>
 219                 public List<Type> ElementExtension
 220                 {
 221                         get { return elementExtension; }
 222                 }
 223
 224                 /// <summary>
 225                 /// Gets or sets the browser validator provider.
 226                 /// </summary>
 227                 /// <value>The browser validator provider.</value>
 228                 public Type BrowserValidatorProvider
 229                 {
 230                         get { return browserValidatorProvider; }
 231                         set { browserValidatorProvider = value; }
 232                 }
 233         }
 234 }