public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
        {
            if(_serviceProvider==null)
            {
              return null;
            }
            var componentFactory = (IViewComponentFactory)_serviceProvider.GetService(typeof(IViewComponentFactory));
            if (componentFactory == null || componentFactory.Registry == null)
                return null;

            ViewComponentInfo viewComponentInfo;
            lock (_cachedViewComponent)
            {
                if (!_cachedViewComponent.TryGetValue(node.Name, out viewComponentInfo))
                {
                    if (componentFactory.Registry.HasViewComponent(node.Name))
                    {
                        viewComponentInfo = new ViewComponentInfo(componentFactory.Create(node.Name));
                        _cachedViewComponent.Add(node.Name, viewComponentInfo);
                    }
                    else
                    {
                        _cachedViewComponent.Add(node.Name, null);
                    }
                }
            }

            if (viewComponentInfo != null)
            {
                return new ViewComponentExtension(node, viewComponentInfo);
            }

            return null;
        }

		private static IEnumerable<IReplacement> GetApplicableReplacements(ElementNode node)
		{
			var result = new List<IReplacement>();
			result.AddRange(UriReplacementSpecifications.GetMatching(node));
			result.AddRange(FormReplacementSpecifications.GetMatching(node));
			return result;
		}

 protected void Transform(ElementNode elementNode, IList<Node> body)
 {
     foreach (IReplacement replacement in replacements)
     {
         replacement.DoReplace(elementNode);
     }
 }

        public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
        {
            if (node.Name == "unittest")
                return new TestExtension();

            return null;
        }

 public void DoReplace(ElementNode node, IList<Node> body)
 {
     string propertyExpression = node.GetAttributeValue("for");
     Node checkedSnippet = propertyExpression.GetCheckedSnippet();
     node.RemoveAttributesByName("checked");
     node.Attributes.Add(new AttributeNode("checked", new List<Node>(){checkedSnippet}));
 }

		protected static void AddAttribute(ElementNode elementNode, string attributeName, Node childNode)
		{
			elementNode.RemoveAttributesByName(attributeName);
			elementNode.Attributes.Add(new AttributeNode(attributeName, new List<Node>
			                                                            	{
			                                                            		childNode
			                                                            	}));
		}

 public void NonVoidElementDoesNotSelfClose()
 {
     var elt = new ElementNode("span", new AttributeNode[]{ }, true);
     var visitor = new ChunkBuilderVisitor(new VisitorContext());
     visitor.Accept(elt);
     Assert.AreEqual(1, visitor.Chunks.Count());
     Assert.AreEqual("<span></span>", ((SendLiteralChunk)visitor.Chunks[0]).Text);
 }

		private Node RemoteAndEvalUriSnippet(ElementNode elementNode)
		{
			string attribValue = elementNode.GetAttributeValue(replacementSpecification.OriginalAttributeName);
			elementNode.RemoveAttributesByName(replacementSpecification.OriginalAttributeName);
			return
				attribValue.GetCreateUriSnippet(
					IsTypeReplacement());
		}

        private AttributeNode ExtractFakeAttribute(ElementNode node, string name, string fakeName)
        {
            var attribute = node.Attributes.SingleOrDefault(x => AttrName(x) == name);
            if (attribute == null)
                return null;

            node.Attributes.Remove(attribute);
            return new AttributeNode(fakeName, '"', attribute.Nodes);
        }

		private static IEnumerable<IReplacement> GetMiscReplacements(ElementNode node)
		{
			IEnumerable<IReplacement> result =
				TextAreaSpecs.Where(x => x.IsMatch(node)).Select(x => new TextAreaValueReplacement(x)).Cast<IReplacement>();
			result =
				result.Union(
					SelectSpecs.Where(x => x.IsMatch(node)).Select(x => new SelectSelectedValueReplacement(x)).Cast<IReplacement>());
			return result;
		}

		public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
		{
			IEnumerable<IReplacement> replacements = GetApplicableReplacements(node);
			if (replacements.Any())
			{
				return new SparkExtension(node, replacements);
			}
			return null;
		}

 public ISparkElementTransformer CreateElementTransformer(ElementNode elementNode)
 {
     var sparkElementWrapper = new SparkElementWrapper(elementNode);
     if(!_elementTransformerService.IsTransformable(sparkElementWrapper))
     {
         return new NullSparkElementTransformer();
     }
     return new SparkElementTransformer(_elementTransformerService.GetTransformerFor(sparkElementWrapper));
 }

 public ISparkElementTransformer CreateElementTransformer(ElementNode elementNode)
 {
     var tag = new Tag(elementNode.Name, elementNode.Attributes.Select(x=>new TagAttribute(x.Name, x.Value)).ToArray());
     if(!_elementTransformerService.IsTransformable(tag))
     {
         return new NullSparkElementTransformer();
     }
     return new SparkElementTransformer(_elementTransformerService.GetTransformerFor(tag));
 }

 public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
 {
     ISparkElementTransformer elementTransformer = _sparkElementTransformerService.CreateElementTransformer(node);
     if(elementTransformer is NullSparkElementTransformer)
     {
         return null;
     }
     return new SparkOverrideExtension(node, elementTransformer);
 }

		public void DoReplace(ElementNode node)
		{
			RemoveReplacedAttribute(node);
			Node uriSnippet = RemoteAndEvalUriSnippet(node);

			node.Attributes.Add(new AttributeNode(replacementSpecification.NewAttributeName, new List<Node>()
			                                                                                 	{
			                                                                                 		uriSnippet
			                                                                                 	}));
		}

 public TargetExtension(VisitorContext context, ElementNode targetElement, int targetExtensionCount)
 {
     _context = context;
     _targetElement = targetElement;
     _targetExtensionCount = targetExtensionCount;
     _idAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "id");
     _classAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "class");
     _descriptionAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "description");
     _targetAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "target");
 }

		public static IEnumerable<IReplacement> GetMatching(ElementNode node)
		{
			// should create the urireplacements on static construction
			var result = new List<IReplacement>();
			result.AddRange(GetNameReplacements(node));
			result.AddRange(GetValueReplacements(node));
			result.AddRange(GetMiscReplacements(node));
			result.AddRange(GetTidyReplacements(node));
			return result;
		}

 public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
 {
     if (string.Equals(node.Name, "div", StringComparison.OrdinalIgnoreCase))
     {
         return new TargetExtension(context, node, ++_TargetExtensionCount);
     } if (string.Equals(node.Name, "functions", StringComparison.OrdinalIgnoreCase))
     {
         return new FunctionsExtension(context, node);
     }
     return null;
 }

        public void NodeShouldBeTakenFromTransformer()
        {
            var elementTransformer = MockRepository.GenerateStub<ISparkElementTransformer>();
            Node transformedNode = new ElementNode("transformed", new List<AttributeNode>(), false);
            IList<Node> body = new List<Node>();
            var extension = new SparkOverrideExtension(elementTransformer);

            extension.VisitNode(new StubNodeVisitor(), body, null);

            elementTransformer.AssertWasCalled(x => x.Transform(body));
        }

        public void ShouldAppendEndElementIfNodeIsNotEmpty()
        {
            var elementTransformer = MockRepository.GenerateStub<ISparkElementTransformer>();
            Node transformedNode = new ElementNode("transformed", new List<AttributeNode>(), false);
            elementTransformer.Stub(x => x.Transform(null)).IgnoreArguments().Return(transformedNode);
            var extension = new SparkOverrideExtension(elementTransformer);
            var stubNodeVisitor = new StubNodeVisitor();

            extension.VisitNode(stubNodeVisitor, new List<Node>(), null);

            stubNodeVisitor.Nodes.LastOrDefault().As<EndElementNode>().Name.ShouldEqual("transformed");
        }