[Yafdotnet-cvs] yafsrc/URLRewriter.NET/Configuration ActionParserFactory.cs, NONE, 1.1.2.1 ConditionParserPipeline.cs, NONE, 1.1.2.1 RewriterConfiguration.cs, NONE, 1.1.2.1 RewriterConfigurationReader.cs, NONE, 1.1.2.1 RewriterConfigurationSectionHandler.cs, NONE, 1.1.2.1 TransformFactory.cs, NONE, 1.1.2.1

[Jaben C. <ja...@us...>]

Update of /cvsroot/yafdotnet/yafsrc/URLRewriter.NET/Configuration
In directory sc8-pr-cvs10.sourceforge.net:/tmp/cvs-serv25871/yafsrc/URLRewriter.NET/Configuration

Added Files:
      Tag: v1_0_2_NETv2
	ActionParserFactory.cs ConditionParserPipeline.cs 
	RewriterConfiguration.cs RewriterConfigurationReader.cs 
	RewriterConfigurationSectionHandler.cs TransformFactory.cs 
Log Message:
URL Rewriter class

--- NEW FILE: ActionParserFactory.cs ---
// UrlRewriter - A .NET URL Rewriter module
// Version 1.7
//
// Copyright 2006 Intelligencia
// Copyright 2006 Seth Yates
// 

using System;
using System.Collections;
using Intelligencia.UrlRewriter.Utilities;

namespace Intelligencia.UrlRewriter.Configuration
{
	/// <summary>
	/// Factory for creating the action parsers.
	/// </summary>
	public class ActionParserFactory
	{
		/// <summary>
		/// Adds a parser.
		/// </summary>
		/// <param name="parserType">The parser type.</param>
		public void AddParser(string parserType)
		{
			AddParser((IRewriteActionParser)TypeHelper.Activate(parserType, null));
		}

		/// <summary>
		/// Adds a parser.
		/// </summary>
		/// <param name="parser">The parser.</param>
		public void AddParser(IRewriteActionParser parser)
		{
			ArrayList list;
			if (_parsers.ContainsKey(parser.Name))
			{
				list = (ArrayList)_parsers[parser.Name];
			}
			else
			{
				list = new ArrayList();
				_parsers.Add(parser.Name, list);
			}
			list.Add(parser);
		}

		/// <summary>
		/// Returns a list of parsers for the given verb.
		/// </summary>
		/// <param name="verb">The verb.</param>
		/// <returns>A list of parsers</returns>
		public IList GetParsers(string verb)
		{
			if (_parsers.ContainsKey(verb))
			{
				return (ArrayList)_parsers[verb];
			}
			else
			{
				return null;
			}
		}

		private Hashtable _parsers = new Hashtable();
	}
}

--- NEW FILE: RewriterConfiguration.cs ---
// UrlRewriter - A .NET URL Rewriter module
// Version 1.7
//
// Copyright 2006 Intelligencia
// Copyright 2006 Seth Yates
// 

using System;
using System.IO;
using System.Xml;
using System.Web;
using System.Web.Caching;
using System.Text.RegularExpressions;
using System.Collections;
using System.Configuration;
using System.Reflection;
using Intelligencia.UrlRewriter.Parsers;
using Intelligencia.UrlRewriter.Transforms;
using Intelligencia.UrlRewriter.Utilities;
using Intelligencia.UrlRewriter.Logging;

namespace Intelligencia.UrlRewriter.Configuration
{
	/// <summary>
	/// Configuration for the URL rewriter.
	/// </summary>
	public class RewriterConfiguration
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		internal RewriterConfiguration()
		{
			_xPoweredBy = MessageProvider.FormatString(Message.ProductName, Assembly.GetExecutingAssembly().GetName().Version.ToString(3));

			_actionParserFactory = new ActionParserFactory();
			_actionParserFactory.AddParser(new ConditionActionParser());
			_actionParserFactory.AddParser(new AddHeaderActionParser());
			_actionParserFactory.AddParser(new SetCookieActionParser());
			_actionParserFactory.AddParser(new SetPropertyActionParser());
			_actionParserFactory.AddParser(new RewriteActionParser());
			_actionParserFactory.AddParser(new IfRewriteActionParser());
			_actionParserFactory.AddParser(new RedirectActionParser());
			_actionParserFactory.AddParser(new IfRedirectActionParser());
			_actionParserFactory.AddParser(new SetStatusActionParser());
			_actionParserFactory.AddParser(new ForbiddenActionParser());
			_actionParserFactory.AddParser(new GoneActionParser());
			_actionParserFactory.AddParser(new NotAllowedActionParser());
			_actionParserFactory.AddParser(new NotFoundActionParser());
			_actionParserFactory.AddParser(new NotImplementedActionParser());

			_conditionParserPipeline = new ConditionParserPipeline();
			_conditionParserPipeline.AddParser(new AddressConditionParser());
			_conditionParserPipeline.AddParser(new HeaderMatchConditionParser());
			_conditionParserPipeline.AddParser(new MethodConditionParser());
			_conditionParserPipeline.AddParser(new PropertyMatchConditionParser());
			_conditionParserPipeline.AddParser(new ExistsConditionParser());
			_conditionParserPipeline.AddParser(new UrlMatchConditionParser());

			_transformFactory = new TransformFactory();
			_transformFactory.AddTransform(new DecodeTransform());
			_transformFactory.AddTransform(new EncodeTransform());
			_transformFactory.AddTransform(new LowerTransform());
			_transformFactory.AddTransform(new UpperTransform());
			_transformFactory.AddTransform(new Base64Transform());
			_transformFactory.AddTransform(new Base64DecodeTransform());
		}

		/// <summary>
		/// The rules.
		/// </summary>
		public IList Rules
		{
			get
			{
				return _rules;
			}
		}

		/// <summary>
		/// The action parser factory.
		/// </summary>
		public ActionParserFactory ActionParserFactory
		{
			get
			{
				return _actionParserFactory;
			}
		}

		/// <summary>
		/// The transform factory.
		/// </summary>
		public TransformFactory TransformFactory
		{
			get
			{
				return _transformFactory;
			}
		}

		/// <summary>
		/// The condition parser pipeline.
		/// </summary>
		public ConditionParserPipeline ConditionParserPipeline
		{
			get
			{
				return _conditionParserPipeline;
			}
		}

		/// <summary>
		/// Dictionary of error handlers.
		/// </summary>
		public IDictionary ErrorHandlers
		{
			get
			{
				return _errorHandlers;
			}
		}

		/// <summary>
		/// Logger to use for logging information.
		/// </summary>
		public IRewriteLogger Logger
		{
			get
			{
				return _logger;
			}
			set
			{
				_logger = value;
			}
		}

		internal string XPoweredBy
		{
			get
			{
				return _xPoweredBy;
			}
		}

		/// <summary>
		/// Creates a new configuration with only the default entries.
		/// </summary>
		/// <returns></returns>
		public static RewriterConfiguration Create()
		{
			return new RewriterConfiguration();
		}

		/// <summary>
		/// The current configuration.
		/// </summary>
		public static RewriterConfiguration Current
		{
			get
			{
				RewriterConfiguration configuration = HttpRuntime.Cache.Get(typeof(RewriterConfiguration).AssemblyQualifiedName) as RewriterConfiguration;
				if (configuration == null)
				{
					configuration = Load();
				}

				return configuration;
			}
		}

		/// <summary>
		/// Loads the configuration from the .config file, with caching.
		/// </summary>
		/// <returns>The configuration.</returns>
		public static RewriterConfiguration Load()
		{
			XmlNode section = ConfigurationSettings.GetConfig(Constants.RewriterNode) as XmlNode;
			RewriterConfiguration config = null;

			XmlNode filenameNode = section.Attributes.GetNamedItem(Constants.AttrFile);
			if (filenameNode != null)
			{
				string filename = HttpContext.Current.Server.MapPath(filenameNode.Value);
				config = LoadFromFile(filename);
				if (config != null)
				{
					CacheDependency fileDependency = new CacheDependency(filename);
					HttpRuntime.Cache.Add(typeof(RewriterConfiguration).AssemblyQualifiedName, config, fileDependency, DateTime.Now.AddHours(1.0), TimeSpan.Zero, CacheItemPriority.Default, null);
				}
			}

			if (config == null)
			{
				config = LoadFromNode(section);
				HttpRuntime.Cache.Add(typeof(RewriterConfiguration).AssemblyQualifiedName, config, null, DateTime.Now.AddHours(1.0), TimeSpan.Zero, CacheItemPriority.Default, null);
			}

			return config;
		}

		/// <summary>
		/// Loads the configuration from an external XML file.
		/// </summary>
		/// <param name="filename">The filename of the file to load configuration from.</param>
		/// <returns>The configuration.</returns>
		public static RewriterConfiguration LoadFromFile(string filename)
		{
			if (File.Exists(filename))
			{
				XmlDocument document = new XmlDocument();
				document.Load(filename);

				return LoadFromNode(document.DocumentElement);
			}

			return null;
		}

		/// <summary>
		/// Loads the configuration from an XML node.
		/// </summary>
		/// <param name="node">The XML node to load configuration from.</param>
		/// <returns>The configuration.</returns>
		public static RewriterConfiguration LoadFromNode(XmlNode node)
		{
			RewriterConfigurationReader reader = new RewriterConfigurationReader();
			return (RewriterConfiguration)reader.Read(node);
		}

		private IRewriteLogger _logger = new NullLogger();
		private Hashtable _errorHandlers = new Hashtable();
		private ArrayList _rules = new ArrayList();
		private ActionParserFactory _actionParserFactory;
		private ConditionParserPipeline _conditionParserPipeline;
		private TransformFactory _transformFactory;
		private string _xPoweredBy;
	}
}

--- NEW FILE: RewriterConfigurationReader.cs ---
// UrlRewriter - A .NET URL Rewriter module
// Version 1.7
//
// Copyright 2006 Intelligencia
// Copyright 2006 Seth Yates
// 

using System;
using System.Net;
using System.Web;
using System.Xml;
using System.Text;
using System.Configuration;
using System.Reflection;
using System.Collections;
using System.Collections.Specialized;
using System.Text.RegularExpressions;
using Intelligencia.UrlRewriter.Conditions;
using Intelligencia.UrlRewriter.Actions;
using Intelligencia.UrlRewriter.Utilities;
using Intelligencia.UrlRewriter.Parsers;
using Intelligencia.UrlRewriter.Errors;
using Intelligencia.UrlRewriter.Transforms;
using Intelligencia.UrlRewriter.Logging;

namespace Intelligencia.UrlRewriter.Configuration
{
	/// <summary>
	/// Reads configuration from an XML Node.
	/// </summary>
	public class RewriterConfigurationReader
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public RewriterConfigurationReader()
		{
		}

		/// <summary>
		/// Reads configuration information from the given XML Node.
		/// </summary>
		/// <param name="section">The XML node to read configuration from.</param>
		/// <returns>The configuration information.</returns>
		public object Read(XmlNode section)
		{
			RewriterConfiguration config = new RewriterConfiguration();

			foreach (XmlNode node in section.ChildNodes)
			{
				if (node.NodeType == XmlNodeType.Element)
				{
					if (node.LocalName == Constants.ElementErrorHandler)
					{
						ReadErrorHandler(node, config);
					}
					else if (node.LocalName == Constants.ElementRegister)
					{
						if (node.Attributes[Constants.AttrParser] != null)
						{
							ReadRegisterParser(node, config);
						}
						else if (node.Attributes[Constants.AttrTransform] != null)
						{
							ReadRegisterTransform(node, config);
						}
						else if (node.Attributes[Constants.AttrLogger] != null)
						{
							ReadRegisterLogger(node, config);
						}
					}
					else if (node.LocalName == Constants.ElementMapping)
					{
						ReadMapping(node, config);
					}
					else
					{
						ReadRule(node, config);
					}
				}
			}

			return config;
		}

		private void ReadRegisterTransform(XmlNode node, RewriterConfiguration config)
		{
			// Type attribute.
			XmlNode typeNode = node.Attributes[Constants.AttrTransform];
			if (typeNode == null)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrTransform), node);
			}

			if (node.ChildNodes.Count > 0)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node);
			}

			// Transform type specified.  Create an instance and add it
			// as the mapper handler for this map.
			IRewriteTransform handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteTransform;
			if (handler != null)
			{
				config.TransformFactory.AddTransform(handler);
			}
			else
			{
				// TODO: Error due to type.
			}
		}

		private void ReadRegisterLogger(XmlNode node, RewriterConfiguration config)
		{
			// Type attribute.
			XmlNode typeNode = node.Attributes[Constants.AttrLogger];
			if (typeNode == null)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrLogger), node);
			}

			if (node.ChildNodes.Count > 0)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node);
			}

			// Logger type specified.  Create an instance and add it
			// as the mapper handler for this map.
			IRewriteLogger logger = TypeHelper.Activate(typeNode.Value, null) as IRewriteLogger;
			if (logger != null)
			{
				config.Logger = logger;
			}
		}

		private void ReadRegisterParser(XmlNode node, RewriterConfiguration config)
		{
			XmlNode typeNode = node.Attributes[Constants.AttrParser];
			if (typeNode == null)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrParser), node);
			}

			if (node.ChildNodes.Count > 0)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node);
			}

			object parser = TypeHelper.Activate(typeNode.Value, null);
			if (parser is IRewriteActionParser)
			{
				config.ActionParserFactory.AddParser(parser as IRewriteActionParser);
			}

			if (parser is IRewriteConditionParser)
			{
				config.ConditionParserPipeline.AddParser(parser as IRewriteConditionParser);
			}
		}

		private void ReadErrorHandler(XmlNode node, RewriterConfiguration config)
		{
			XmlNode codeNode = node.Attributes[Constants.AttrCode];
			if (codeNode == null)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrCode), node);
			}

			XmlNode typeNode = node.Attributes[Constants.AttrType];
			XmlNode urlNode = node.Attributes[Constants.AttrUrl];
			if (typeNode == null && urlNode == null)
			{
				throw new ConfigurationException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrUrl), node);
			}

			IRewriteErrorHandler handler = null;
			if (typeNode != null)
			{
				// <error-handler code="500" url="/oops.aspx" />
				handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteErrorHandler;
				if (handler == null)
				{
					throw new ConfigurationException(MessageProvider.FormatString(Message.InvalidTypeSpecified));
				}
			}
			else
			{
				handler = new DefaultErrorHandler(urlNode.Value);
			}

			config.ErrorHandlers.Add(Convert.ToInt32(codeNode.Value), handler);
		}

		private void ReadMapping(XmlNode node, RewriterConfiguration config)
		{
			// Name attribute.
			XmlNode nameNode = node.Attributes[Constants.AttrName];

			// Mapper type not specified.  Load in the hash map.
			StringDictionary map = new StringDictionary();
			foreach (XmlNode mapNode in node.ChildNodes)
			{
				if (mapNode.LocalName == Constants.ElementMap)
				{
					XmlNode fromValueNode = mapNode.Attributes[Constants.AttrFrom];
					if (fromValueNode == null)
					{
						throw new ConfigurationException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrFrom), node);
					}

					XmlNode toValueNode = mapNode.Attributes[Constants.AttrTo];
					if (toValueNode == null)
					{
						throw new ConfigurationException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrTo), node);
					}

					map.Add(fromValueNode.Value, toValueNode.Value);
				}
				else
				{
					throw new ConfigurationException(MessageProvider.FormatString(Message.ElementNotAllowed, mapNode.LocalName), node);
				}
			}

			config.TransformFactory.AddTransform(new StaticMappingTransform(nameNode.Value, map));
		}

		private void ReadRule(XmlNode node, RewriterConfiguration config)
		{
			bool parsed = false;
			IList parsers = config.ActionParserFactory.GetParsers(node.LocalName);
			if (parsers != null)
			{
				foreach (IRewriteActionParser parser in parsers)
				{
					if (!parser.AllowsNestedActions && node.ChildNodes.Count > 0)
					{
						throw new ConfigurationException(MessageProvider.FormatString(Message.ElementNoElements, parser.Name), node);
					}

					if (!parser.AllowsAttributes && node.Attributes.Count > 0)
					{
						throw new ConfigurationException(MessageProvider.FormatString(Message.ElementNoAttributes, parser.Name), node);
					}

					IRewriteAction rule = parser.Parse(node, config);
					if (rule != null)
					{
						config.Rules.Add(rule);
						parsed = true;
						break;
					}
				}
			}

			if (!parsed)
			{
				// No parsers recognised to handle this node.
				throw new ConfigurationException(MessageProvider.FormatString(Message.ElementNotAllowed, node.LocalName), node);
			}
		}
	}
}

--- NEW FILE: TransformFactory.cs ---
// UrlRewriter - A .NET URL Rewriter module
// Version 1.7
//
// Copyright 2006 Intelligencia
// Copyright 2006 Seth Yates
// 

using System;
using System.Collections;
using Intelligencia.UrlRewriter.Utilities;

namespace Intelligencia.UrlRewriter.Configuration
{
	/// <summary>
	/// Factory for creating transforms.
	/// </summary>
	public class TransformFactory
	{
		/// <summary>
		/// Adds a transform.
		/// </summary>
		/// <param name="transformType">The type of the transform.</param>
		public void AddTransform(string transformType)
		{
			AddTransform((IRewriteTransform)TypeHelper.Activate(transformType, null));
		}

		/// <summary>
		/// Adds a transform.
		/// </summary>
		/// <param name="transform">The transform object.</param>
		public void AddTransform(IRewriteTransform transform)
		{
			_transforms.Add(transform.Name, transform);
		}

		/// <summary>
		/// Gets a transform by name.
		/// </summary>
		/// <param name="name">The transform name.</param>
		/// <returns>The transform object.</returns>
		public IRewriteTransform GetTransform(string name)
		{
			return _transforms[name] as IRewriteTransform;
		}

		private Hashtable _transforms = new Hashtable();
	}
}

--- NEW FILE: RewriterConfigurationSectionHandler.cs ---
// UrlRewriter - A .NET URL Rewriter module
// Version 1.7
//
// Copyright 2006 Intelligencia
// Copyright 2006 Seth Yates
// 

using System;
using System.Xml;
using System.Configuration;

namespace Intelligencia.UrlRewriter.Configuration
{
	/// <summary>
	/// Configuration section handler for the rewriter section.
	/// </summary>
	public sealed class RewriterConfigurationSectionHandler : IConfigurationSectionHandler
	{
		/// <summary>
		/// Creates the settings object.
		/// </summary>
		/// <param name="parent">The parent node.</param>
		/// <param name="configContext">The configuration context.</param>
		/// <param name="section">The section.</param>
		/// <returns>The settings object.</returns>
		object IConfigurationSectionHandler.Create(object parent, object configContext, XmlNode section)
		{
			return section;
		}
	}
}

--- NEW FILE: ConditionParserPipeline.cs ---
// UrlRewriter - A .NET URL Rewriter module
// Version 1.7
//
// Copyright 2006 Intelligencia
// Copyright 2006 Seth Yates
// 

using System;
using System.Collections;
using Intelligencia.UrlRewriter.Utilities;

namespace Intelligencia.UrlRewriter.Configuration
{
	/// <summary>
	/// Pipeline for creating the Condition parsers.
	/// </summary>
	public class ConditionParserPipeline : CollectionBase
	{
		/// <summary>
		/// Adds a parser.
		/// </summary>
		/// <param name="parserType">The parser type.</param>
		public void AddParser(string parserType)
		{
			AddParser((IRewriteConditionParser)TypeHelper.Activate(parserType, null));
		}

		/// <summary>
		/// Adds a parser.
		/// </summary>
		/// <param name="parser">The parser.</param>
		public void AddParser(IRewriteConditionParser parser)
		{
			InnerList.Add(parser);
		}
	}
}