MonoRail/Castle.MonoRail.Framework/Configuration/MonoRailConfiguration.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.Configuration;
  19         using System.Xml;
  20         using Castle.Core.Configuration;
  21         using Castle.Core.Configuration.Xml;
  22         using Castle.MonoRail.Framework.Helpers.ValidationStrategy;
  23         using Castle.MonoRail.Framework.JSGeneration.Prototype;
  24         using JSGeneration;
  25
  26         /// <summary>
  27         /// Represents the MonoRail external configuration
  28         /// </summary>
  29         public class MonoRailConfiguration : IMonoRailConfiguration, ISerializedConfig
  30         {
  31                 private static readonly String SectionName = "monorail";
  32                 private static readonly String AlternativeSectionName = "monoRail";
  33
  34                 private bool matchHostNameAndPath, excludeAppPath;
  35                 private Type customFilterFactory;
  36                 private IConfiguration configurationSection;
  37
  38                 private SmtpConfig smtpConfig;
  39                 private ViewEngineConfig viewEngineConfig;
  40                 private ControllersConfig controllersConfig;
  41                 private ViewComponentsConfig viewComponentsConfig;
  42                 private ScaffoldConfig scaffoldConfig;
  43                 private UrlConfig urlConfig;
  44                 private JSGeneratorConfiguration jsGeneratorConfig;
  45                 private RoutingRuleCollection routingRules;
  46                 private ExtensionEntryCollection extensions;
  47                 private DefaultUrlCollection defaultUrls;
  48                 private IConfiguration servicesConfig = new MutableConfiguration("services");
  49
  50                 /// <summary>
  51                 /// Initializes a new instance of the <see cref="MonoRailConfiguration"/> class.
  52                 /// </summary>
  53                 public MonoRailConfiguration()
  54                 {
  55                         smtpConfig = new SmtpConfig();
  56                         viewEngineConfig = new ViewEngineConfig();
  57                         controllersConfig = new ControllersConfig();
  58                         viewComponentsConfig = new ViewComponentsConfig();
  59                         scaffoldConfig = new ScaffoldConfig();
  60                         urlConfig = new UrlConfig();
  61                         routingRules = new RoutingRuleCollection();
  62                         extensions = new ExtensionEntryCollection();
  63                         defaultUrls = new DefaultUrlCollection();
  64                         jsGeneratorConfig = new JSGeneratorConfiguration();
  65
  66                         jsGeneratorConfig.AddLibrary("prototype-1.5.1", typeof(PrototypeGenerator))
  67                                 .AddExtension(typeof(CommonJSExtension))
  68                                 .AddExtension(typeof(ScriptaculousExtension))
  69                                 .AddExtension(typeof(BehaviourExtension))
  70                                 .BrowserValidatorIs(typeof(PrototypeWebValidator))
  71                                 .SetAsDefault();
  72
  73                         // old routing support related
  74                         matchHostNameAndPath = false;
  75                         excludeAppPath = false;
  76                 }
  77
  78                 /// <summary>
  79                 /// Pendent
  80                 /// </summary>
  81                 /// <param name="section"></param>
  82                 public MonoRailConfiguration(XmlNode section) : this()
  83                 {
  84                         configurationSection = XmlConfigurationDeserializer.GetDeserializedNode(section);
  85                 }
  86
  87                 /// <summary>
  88                 /// Gets the config.
  89                 /// </summary>
  90                 /// <returns></returns>
  91                 public static MonoRailConfiguration GetConfig()
  92                 {
  93                         MonoRailConfiguration config =
  94                                 ConfigurationManager.GetSection(SectionName) as MonoRailConfiguration;
  95
  96                         if (config == null)
  97                         {
  98                                 config = ConfigurationManager.GetSection(AlternativeSectionName) as MonoRailConfiguration;
  99                         }
 100
 101                         return config;
 102                 }
 103
 104                 #region ISerializedConfig implementation
 105
 106                 /// <summary>
 107                 /// Deserializes the specified node.
 108                 /// </summary>
 109                 /// <param name="node">The node.</param>
 110                 public void Deserialize(XmlNode node)
 111                 {
 112                         viewEngineConfig.Deserialize(node);
 113                         smtpConfig.Deserialize(node);
 114                         controllersConfig.Deserialize(node);
 115                         viewComponentsConfig.Deserialize(node);
 116                         scaffoldConfig.Deserialize(node);
 117                         urlConfig.Deserialize(node);
 118
 119                         extensions.Deserialize(node);
 120                         routingRules.Deserialize(node);
 121                         defaultUrls.Deserialize(node);
 122
 123                         ProcessFilterFactoryNode(node.SelectSingleNode("customFilterFactory"));
 124                         ProcessMatchHostNameAndPath(node.SelectSingleNode("routing"));
 125                         ProcessExcludeAppPath(node.SelectSingleNode("routing"));
 126
 127                         XmlNode services = node.SelectSingleNode("services");
 128
 129                         if (services != null)
 130                         {
 131                                 servicesConfig = XmlConfigurationDeserializer.GetDeserializedNode(services);
 132                         }
 133                 }
 134
 135                 #endregion
 136
 137                 /// <summary>
 138                 /// Gets the SMTP config.
 139                 /// </summary>
 140                 /// <value>The SMTP config.</value>
 141                 public SmtpConfig SmtpConfig
 142                 {
 143                         get { return smtpConfig; }
 144                 }
 145
 146                 /// <summary>
 147                 /// Gets the view engine config.
 148                 /// </summary>
 149                 /// <value>The view engine config.</value>
 150                 public ViewEngineConfig ViewEngineConfig
 151                 {
 152                         get { return viewEngineConfig; }
 153                 }
 154
 155                 /// <summary>
 156                 /// Gets the controllers config.
 157                 /// </summary>
 158                 /// <value>The controllers config.</value>
 159                 public ControllersConfig ControllersConfig
 160                 {
 161                         get { return controllersConfig; }
 162                         set { controllersConfig = value; }
 163                 }
 164
 165                 /// <summary>
 166                 /// Gets the view components config.
 167                 /// </summary>
 168                 /// <value>The view components config.</value>
 169                 public ViewComponentsConfig ViewComponentsConfig
 170                 {
 171                         get { return viewComponentsConfig; }
 172                         set { viewComponentsConfig = value; }
 173                 }
 174
 175                 /// <summary>
 176                 /// Gets the routing rules.
 177                 /// </summary>
 178                 /// <value>The routing rules.</value>
 179                 public RoutingRuleCollection RoutingRules
 180                 {
 181                         get { return routingRules; }
 182                         set { routingRules = value; }
 183                 }
 184
 185                 /// <summary>
 186                 /// Gets the extension entries.
 187                 /// </summary>
 188                 /// <value>The extension entries.</value>
 189                 public ExtensionEntryCollection ExtensionEntries
 190                 {
 191                         get { return extensions; }
 192                 }
 193
 194                 /// <summary>
 195                 /// Gets the custom filter factory.
 196                 /// </summary>
 197                 /// <value>The custom filter factory.</value>
 198                 public Type CustomFilterFactory
 199                 {
 200                         get { return customFilterFactory; }
 201                         set { customFilterFactory = value; }
 202                 }
 203
 204                 /// <summary>
 205                 /// Gets the scaffold config.
 206                 /// </summary>
 207                 /// <value>The scaffold config.</value>
 208                 public ScaffoldConfig ScaffoldConfig
 209                 {
 210                         get { return scaffoldConfig; }
 211                         set { scaffoldConfig = value; }
 212                 }
 213
 214                 /// <summary>
 215                 /// Gets the url config.
 216                 /// </summary>
 217                 /// <value>The url config.</value>
 218                 public UrlConfig UrlConfig
 219                 {
 220                         get { return urlConfig; }
 221                         set { urlConfig = value; }
 222                 }
 223
 224                 /// <summary>
 225                 /// Gets or sets the JS generator configuration.
 226                 /// </summary>
 227                 /// <value>The JS generator configuration.</value>
 228                 public JSGeneratorConfiguration JSGeneratorConfiguration
 229                 {
 230                         get { return jsGeneratorConfig; }
 231                         set { jsGeneratorConfig = value; }
 232                 }
 233
 234                 /// <summary>
 235                 /// Gets a value indicating whether match host name and path should be used on
 236                 /// MonoRail routing.
 237                 /// </summary>
 238                 /// <value>
 239                 ///     <c>true</c> if it should match host name and path; otherwise, <c>false</c>.
 240                 /// </value>
 241                 public bool MatchHostNameAndPath
 242                 {
 243                         get { return matchHostNameAndPath; }
 244                         set { matchHostNameAndPath = value; }
 245                 }
 246
 247                 /// <summary>
 248                 /// Gets a value indicating whether routing should exclude app path.
 249                 /// </summary>
 250                 /// <value><c>true</c> if exclude app path; otherwise, <c>false</c>.</value>
 251                 public bool ExcludeAppPath
 252                 {
 253                         get { return excludeAppPath; }
 254                         set { excludeAppPath = value; }
 255                 }
 256
 257                 /// <summary>
 258                 /// Gets the configuration section.
 259                 /// </summary>
 260                 /// <value>The configuration section.</value>
 261                 public IConfiguration ConfigurationSection
 262                 {
 263                         get { return configurationSection; }
 264                         set { configurationSection = value; }
 265                 }
 266
 267                 /// <summary>
 268                 /// Gets the default urls.
 269                 /// </summary>
 270                 /// <value>The default urls.</value>
 271                 public DefaultUrlCollection DefaultUrls
 272                 {
 273                         get { return defaultUrls; }
 274                 }
 275
 276                 /// <summary>
 277                 /// Gets or sets the services config.
 278                 /// </summary>
 279                 /// <value>The services config.</value>
 280                 public IConfiguration ServicesConfig
 281                 {
 282                         get { return servicesConfig; }
 283                         set { servicesConfig = value; }
 284                 }
 285
 286                 private void ProcessFilterFactoryNode(XmlNode node)
 287                 {
 288                         if (node == null) return;
 289
 290                         XmlAttribute type = node.Attributes["type"];
 291
 292                         if (type == null)
 293                         {
 294                                 String message = "The custom filter factory node must specify a 'type' attribute";
 295                                 throw new ConfigurationErrorsException(message);
 296                         }
 297
 298                         customFilterFactory = TypeLoadUtil.GetType(type.Value);
 299                 }
 300
 301                 private void ProcessMatchHostNameAndPath(XmlNode node)
 302                 {
 303                         if (node == null) return;
 304
 305                         XmlAttribute matchHostNameAndPathAtt = node.Attributes["matchHostNameAndPath"];
 306
 307                         if (matchHostNameAndPathAtt != null && matchHostNameAndPathAtt.Value != String.Empty)
 308                         {
 309                                 matchHostNameAndPath = String.Compare(matchHostNameAndPathAtt.Value, "true", true) == 0;
 310                         }
 311                 }
 312
 313                 private void ProcessExcludeAppPath(XmlNode node)
 314                 {
 315                         if (node == null) return;
 316
 317                         // maybe a check to make sure both matchHostNameAndPathAtt & includeAppPath
 318                         // are not both set as that wouldn't make sense?
 319                         XmlAttribute excludeAppPathAtt = node.Attributes["excludeAppPath"];
 320
 321                         if (excludeAppPathAtt != null && excludeAppPathAtt.Value != String.Empty)
 322                         {
 323                                 excludeAppPath = String.Compare(excludeAppPathAtt.Value, "true", true) == 0;
 324                         }
 325                 }
 326         }
 327 }