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}));
 }
Пример #2
0
        public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
        {
            if (node.Name == "unittest")
                return new TestExtension();

            return null;
        }
Пример #3
0
        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);
     }
 }
Пример #6
0
		protected static void AddAttribute(ElementNode elementNode, string attributeName, Node childNode)
		{
			elementNode.RemoveAttributesByName(attributeName);
			elementNode.Attributes.Add(new AttributeNode(attributeName, new List<Node>
			                                                            	{
			                                                            		childNode
			                                                            	}));
		}
		private Node RemoteAndEvalUriSnippet(ElementNode elementNode)
		{
			string attribValue = elementNode.GetAttributeValue(replacementSpecification.OriginalAttributeName);
			elementNode.RemoveAttributesByName(replacementSpecification.OriginalAttributeName);
			return
				attribValue.GetCreateUriSnippet(
					IsTypeReplacement());
		}
Пример #8
0
 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);
 }
 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 ISparkElementTransformer CreateElementTransformer(ElementNode elementNode)
 {
     var sparkElementWrapper = new SparkElementWrapper(elementNode);
     if(!_elementTransformerService.IsTransformable(sparkElementWrapper))
     {
         return new NullSparkElementTransformer();
     }
     return new SparkElementTransformer(_elementTransformerService.GetTransformerFor(sparkElementWrapper));
 }
		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)
 {
     ISparkElementTransformer elementTransformer = _sparkElementTransformerService.CreateElementTransformer(node);
     if(elementTransformer is NullSparkElementTransformer)
     {
         return null;
     }
     return new SparkOverrideExtension(node, elementTransformer);
 }
		public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
		{
			IEnumerable<IReplacement> replacements = GetApplicableReplacements(node);
			if (replacements.Any())
			{
				return new SparkExtension(node, replacements);
			}
			return null;
		}
Пример #14
0
        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);
        }
		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 void DoReplace(ElementNode node)
		{
			RemoveReplacedAttribute(node);
			Node uriSnippet = RemoteAndEvalUriSnippet(node);

			node.Attributes.Add(new AttributeNode(replacementSpecification.NewAttributeName, new List<Node>()
			                                                                                 	{
			                                                                                 		uriSnippet
			                                                                                 	}));
		}
Пример #17
0
 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");
 }
Пример #18
0
 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");
        }
 public override void DoReplace(ElementNode node, IList<Node> body)
 {
     IEnumerable<ElementNode> options = GetOptions(body);
     foreach (ElementNode option in options)
     {
         string currentSelectedValue = option.GetAttributeValue("selected");
         string propertyValue = option.GetAttributeValue("value");
         string propertyExpression = node.GetAttributeValue(ReplacementSpecification.OriginalAttributeName);
         Node selectedNode = propertyExpression.GetSelectedSnippet(currentSelectedValue, propertyValue);
         option.RemoveAttributesByName("selected");
         AddAttribute(option, "selected", selectedNode);
     }
 }
Пример #22
0
        protected override void Visit(ElementNode element)
        {
            var binding = MatchElementBinding(element);
            if (binding == null)
            {
                base.Visit(element);
                return;
            }

            var snippets = binding.Nodes.SelectMany(bindingNode => BuildSnippetsForNode(binding, bindingNode, element));
            var expression = new ExpressionNode(snippets);
            Accept(expression);
        }
Пример #23
0
        private static IEnumerable<Snippet> BuildSnippets(BindingNameReference reference, ElementNode element)
        {
            var attrs = element.Attributes.Where(attr => attr.Name == reference.Name);

            if (reference.AssumeStringValue)
            {
                var builder = new ExpressionBuilder();
                PopulateBuilder(attrs.SelectMany(attr => attr.Nodes), builder);
                return new[] { new Snippet { Value = builder.ToCode() } };
            }

            return attrs.SelectMany(attr => attr.AsCode());
        }
        public void ShouldNotRet()
        {
            var elementTransformer = MockRepository.GenerateStub<ISparkElementTransformer>();
            var nodeVisitor = MockRepository.GenerateStub<INodeVisitor>();
            IList<Node> body = new List<Node>();
            Node transformedNode = new ElementNode("transformed", new List<AttributeNode>(), false);
            elementTransformer.Stub(x => x.Transform(body)).Return(transformedNode);
            var extension = new SparkOverrideExtension(elementTransformer);

            extension.VisitNode(nodeVisitor, body, null);

            nodeVisitor.AssertWasCalled(x => x.Accept(transformedNode));
            nodeVisitor.AssertWasCalled(x => x.Accept(body));
        }
Пример #25
0
        protected override bool IsSpecialAttribute(ElementNode element, AttributeNode attribute)
        {
            var eltName = NameUtility.GetName(element.Name);
            if (eltName == "for")
                return false;

            if (Context.Namespaces == NamespacesType.Unqualified)
                return attribute.Name == "each";

            if (attribute.Namespace != Constants.Namespace)
                return false;

            return NameUtility.GetName(attribute.Name) == "each";
        }
        public void ShouldVisitTransformedNodeBodyIfNotEmpty()
        {
            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();
            List<Node> body = new List<Node>() {new TextNode("Body text"), new TextNode("Another one")};
            List<Node> expectedNodes = new List<Node> { transformedNode };
            expectedNodes.AddRange(body);

            extension.VisitNode(stubNodeVisitor, body, null);

            stubNodeVisitor.Nodes.ShouldStartWith(expectedNodes);
        }
Пример #27
0
        protected override bool IsSpecialAttribute(ElementNode element, AttributeNode attr)
        {
            var eltName = NameUtility.GetName(element.Name);
            if (eltName == "test" || eltName == "if" || eltName == "elseif" || eltName == "else")
                return false;

            if (Context.Namespaces == NamespacesType.Unqualified)
                return attr.Name == "once";

            if (attr.Namespace != Constants.Namespace)
                return false;

            var nqName = NameUtility.GetName(attr.Name);
            return nqName == "once";
        }
        private static IEnumerable<IReplacement> GetApplicableReplacements(ElementNode node)
        {
            var result = new List<IReplacement>();
            // rf this crap
            if ((node.Name == "input") && (node.HasAttribute("type") && (node.HasAttribute("for"))))
            {
                if (node.Attributes.Where(x => (x.Name == "type") && (x.Value == "checkbox")).Any())
                {
                    result.Add(new CheckBoxCheckedReplacement());
                }
            }
            result.AddRange(UriReplacementSpecifications.GetMatching(node));
            result.AddRange(FormReplacementSpecifications.GetMatching(node));

            return result;
        }
Пример #29
0
        protected override SpecialNode CreateWrappingNode(AttributeNode attr, ElementNode node)
        {
            var attrKey =
                ExtractFakeAttribute(node, "cache", "key") ??
                ExtractFakeAttribute(node, "cache.key", "key");

            var attrExpires =
                ExtractFakeAttribute(node, "cache.expires", "expires");

            var attrSignal =
                ExtractFakeAttribute(node, "cache.signal", "signal");

            var attrNodes = new[] { attrKey, attrExpires, attrSignal }.Where(x => x != null).ToList();

            var fakeElement = new ElementNode("cache", attrNodes, false) { OriginalNode = attr };
            return new SpecialNode(fakeElement);
        }
 private void AddCheckedAttribute(ElementNode elementNode, AttributeNode valueNode)
 {
     if (valueNode != null)
     {
         string entity = valueNode.Value.Split('.').First();
         string code = string.Format("({0}!= null)&&({1})", entity, valueNode.Value);
         ConditionNode conditionNode = new ConditionNode(code)
                                       	{
                                       		Nodes = new List<Node>()
                                       		        	{
                                       		        		new TextNode("true")
                                       		        	}
                                       	};
         elementNode.Attributes.Add(new AttributeNode("checked",
                                    		new List<Node>{conditionNode}
                                    	));
     }
 }
Пример #31
0
 public SpecialNode(ElementNode element)
 {
     this.Element = element;
 }
Пример #32
0
 public ExtensionNode(ElementNode element, ISparkExtension extension)
 {
     Element      = element;
     Extension    = extension;
     OriginalNode = element;
 }
Пример #33
0
 public ExtensionNode(ElementNode element, ISparkExtension extension)
 {
     this.Element      = element;
     this.Extension    = extension;
     base.OriginalNode = element;
 }
Пример #34
0
 public SpecialNode(ElementNode element)
 {
     Element = element;
 }