public void Constructor_LegacyMangledRubyStyleAttribute_GeneratesHtmlAttributeCollectionTag()
{
const string templateLine = "p{a='b'}";
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.Children.First(), Is.InstanceOf<HamlNodeHtmlAttributeCollection>());
}
public void Constructor_HtmlStyleAttribute_GeneratesHtmlAttributeCollectionTag()
{
const string templateLine = "p(a='b')";
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, "", 0));
Assert.That(tag.Children.First(), Is.InstanceOf<HamlNodeHtmlAttributeCollection>());
}
public void Constructor_HtmlStyleAttribute_AttributeCollectionContainsCorrectContent(
string templateLine, string expectedAttributeContent, int expectedaAttrCount)
{
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.Children.First().Content, Is.EqualTo(expectedAttributeContent));
Assert.That(tag.Children.Count(), Is.EqualTo(expectedaAttrCount));
}
public void Constructor_InlineContent_GeneratesCorrectChildTag()
{
const string templateLine = "p Hello world";
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.Children.First(), Is.InstanceOf<HamlNodeTextContainer>());
const string expectedText = "Hello world";
Assert.That(((HamlNodeTextContainer)tag.Children.First()).Content, Is.EqualTo(expectedText));
}
public void Constructor_HtmlStyleAttributeWithContent_GeneratesCorrectChildren()
{
const string templateLine = "p(a='b')Content";
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
const string expectedAttrContent = "(a='b')";
Assert.That(tag.Children.First().Content, Is.EqualTo(expectedAttrContent));
const string expectedStringContent = "Content";
Assert.That(tag.Children.ToList()[1].Content, Is.EqualTo(expectedStringContent));
}
private static IList<HamlNodeTextContainer> GetClassValues(HamlNodeTag nodeTag)
{
var classValues = (from collection in nodeTag.Children.OfType<HamlNodeHtmlAttributeCollection>()
from attr in collection.Children.OfType<HamlNodeHtmlAttribute>()
where attr.Name == "class"
from attrFragment in attr.Children
select (HamlNodeTextContainer)attrFragment).ToList();
classValues.AddRange(nodeTag.Children.OfType<HamlNodeTagClass>().Select(x => new HamlNodeTextContainer(x.SourceFileLineNum, x.Content)));
return classValues;
}
private static IList<HamlNodeTextContainer> GetIdValues(HamlNodeTag nodeTag)
{
var idValues = (from collection in nodeTag.Children.OfType<HamlNodeHtmlAttributeCollection>()
from attr in collection.Children.OfType<HamlNodeHtmlAttribute>()
where attr.Name == "id"
from attrFragment in attr.Children
select (HamlNodeTextContainer)attrFragment).ToList();
var idTag = nodeTag.Children.LastOrDefault(x => x.GetType() == typeof(HamlNodeTagId));
if (idTag != null) idValues.Insert(0, new HamlNodeTextContainer(idTag.SourceFileLineNum, idTag.Content));
return idValues;
}
public void Walk_ClassHtmlAttribute_WritesCorrectClassAttribute()
{
// Arrange
var tagNode = new HamlNodeTag(new HamlLine("p", HamlRuleEnum.Tag, "", 0));
tagNode.AddChild(new HamlNodeHtmlAttributeCollection(0, "(class='class')"));
// Act
_tagWalker.Walk(tagNode);
// Assert
const string expectedIdAttr = @"class='class'";
Assert.That(_classBuilderMock.Build(""), Is.StringContaining(expectedIdAttr));
}
public void Walk_ClassNoteAndClassHtmlAttribute_WritesCorrectIdAttribute()
{
// Arrange
var tagNode = new HamlNodeTag(new HamlLine("p", HamlRuleEnum.Tag, indent: ""));
tagNode.AddChild(new HamlNodeTagClass(new HamlSourceFileMetrics(0, 0, 0, 0), "class2"));
tagNode.AddChild(new HamlNodeHtmlAttributeCollection(new HamlSourceFileMetrics(0, 0, 0, 0), (string) "(class='class1')"));
// Act
_tagWalker.Walk(tagNode);
// Assert
const string expectedIdAttr = @"class='class1 class2'";
Assert.That(_classBuilderMock.Build(""), Is.StringContaining(expectedIdAttr));
}
public void Walk_ClassFollowedByIdNodes_OrderedCorrectly()
{
// Arrange
const string tagId = "id";
const string tagClass = "class";
var tagNode = new HamlNodeTag(new HamlLine("p", HamlRuleEnum.Tag, "", 0));
tagNode.AddChild(new HamlNodeTagClass(0, tagClass));
tagNode.AddChild(new HamlNodeTagId(0, tagId));
// Act
_tagWalker.Walk(tagNode);
// Assert
const string expectedTag = @"<p class='class' id='id'></p>";
Assert.That(_classBuilderMock.Build(""), Is.EqualTo(expectedTag));
}
private void WalkHtmlStyleAttributes(HamlNodeTag nodeTag)
{
var attributeTags = nodeTag.Children.Where(x => x.GetType() == typeof(HamlNodeHtmlAttributeCollection));
foreach (var child in attributeTags)
{
new HamlNodeHtmlAttributeCollectionWalker(ClassBuilder, Options)
.Walk(child);
}
}
private void MakeClassAttribute(HamlNodeTag nodeTag)
{
var classValues = GetClassValues(nodeTag);
AppendClassAttribute(classValues);
}
private void MakeIdAttribute(HamlNodeTag nodeTag)
{
var idValues = GetIdValues(nodeTag);
AppendIdAttribute(idValues);
}
private HamlNode GetLastNonWhitespaceChild(HamlNodeTag nodeTag)
{
return nodeTag.Children.LastOrDefault(x => x.IsWhitespaceNode() == false);
}
private bool IsPreCloseTagWhitespaceTrimmed(HamlNodeTag nodeTag)
{
if (nodeTag.IsMultiLine == false || nodeTag.WhitespaceRemoval == WhitespaceRemoval.Internal)
return true;
var lastNonWhitespaceChild = GetLastNonWhitespaceChild(nodeTag) as HamlNodeTag;
if (lastNonWhitespaceChild == null)
return false;
return (lastNonWhitespaceChild).WhitespaceRemoval == WhitespaceRemoval.Surrounding;
}
public void Constructor_TagWithNamespace_DeterminesTagAndNamespaceCorrectly(string templateLine,
string expectedNamespace, string expectedTag)
{
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.Namespace, Is.EqualTo(expectedNamespace));
Assert.That(tag.TagName, Is.EqualTo(expectedTag));
}
private void AppendTagStart(HamlNodeTag nodeTag)
{
if (nodeTag.IsLeadingWhitespaceTrimmed == false)
ClassBuilder.Append(nodeTag.Indent);
ClassBuilder.Append("<" + nodeTag.NamespaceQualifiedTagName);
}
public void Walk_EmptyAttributeCollectionNode_WritesCorrectAttributes(string tag, string attributes, string expectedOutput)
{
var tagNode = new HamlNodeTag(new HamlLine(tag, HamlRuleEnum.Tag, "", 0));
tagNode.AddChild(new HamlNodeHtmlAttributeCollection(0, attributes));
_tagWalker.Walk(tagNode);
Assert.That(_classBuilderMock.Build(""), Is.EqualTo(expectedOutput));
}
public void Constructor_SimpleTags_DeterminesSelfClosingCorrectly(string templateLine, bool expectedSelfClosing)
{
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.IsSelfClosing, Is.EqualTo(expectedSelfClosing));
}
private void AppendAttributes(HamlNodeTag nodeTag)
{
MakeClassAttribute(nodeTag);
MakeIdAttribute(nodeTag);
WalkHtmlStyleAttributes(nodeTag);
}
public void Walk_NonSelfClosingTags_AppendsCorrectTag(string templateLine, string expectedOutput)
{
// Arrange
var tagNode = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, "", 0));
// Act
_tagWalker.Walk(tagNode);
// Assert
Assert.That(_classBuilderMock.Build(""), Is.StringContaining(expectedOutput));
}
public void Walk_TagWithWhitespaceSupression_SetsCorrectFlag(string templateLine, string expectedVariableContent)
{
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.Children.First().Children.First().Content, Is.EqualTo(expectedVariableContent));
}
public void Walk_WhitespaceRemoval_GeneratesCorrectOutput(string line1, string line2, string line3, string expectedOutput)
{
var tagNode = new HamlNodeTag(new HamlLine(line1, HamlRuleEnum.Tag, "", 0));
tagNode.AddChild(new HamlNodeTag(new HamlLine(line2, HamlRuleEnum.Tag, " ", 0)));
_tagWalker.Walk(tagNode);
Assert.That(_classBuilderMock.Build(""), Is.EqualTo(expectedOutput));
}
public void Walk_TagWithWhitespaceSupression_SetsCorrectFlag(string templateLine, WhitespaceRemoval expectedSetting)
{
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.WhitespaceRemoval, Is.EqualTo(expectedSetting));
}
public void Walk_SelfClosingTag_AppendsCorrectTag()
{
// Arrange
const string tagName = "foo/";
var tagNode = new HamlNodeTag(new HamlLine(tagName, HamlRuleEnum.Tag, "", 0));
// Act
_tagWalker.Walk(tagNode);
// Assert
const string expectedTag = "<foo />";
Assert.That(_classBuilderMock.Build(""), Is.StringContaining(expectedTag));
}
public void Constructor_SimpleTags_GeneratesCorrectClassChildNodes(string templateLine, string expectedFirstClass, int expectedCount)
{
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
var classChildren = tag.Children.OfType<HamlNodeTagClass>();
Assert.That(classChildren.Count(), Is.EqualTo(expectedCount));
string att = classChildren.FirstOrDefault() != null ? classChildren.First().Content : "";
Assert.That(att, Is.EqualTo(expectedFirstClass));
}
public void Walk_MultipleIdNodes_WritesCorrectIdAttribute()
{
// Arrange
var tagNode = new HamlNodeTag(new HamlLine("p", HamlRuleEnum.Tag, "", 0));
tagNode.AddChild(new HamlNodeTagId(0, "id1"));
tagNode.AddChild(new HamlNodeTagId(0, "id2"));
// Act
_tagWalker.Walk(tagNode);
// Assert
const string expectedIdAttr = @"id='id2'";
Assert.That(_classBuilderMock.Build(""), Is.StringContaining(expectedIdAttr));
}
public void Constructor_SimpleTags_GeneratesCorrectTagName(string templateLine, string expectedTagName)
{
var tag = new HamlNodeTag(new HamlLine(templateLine, HamlRuleEnum.Tag, indent: ""));
Assert.That(tag.TagName, Is.EqualTo(expectedTagName));
}
private void AppendTagBodyAndClose(HamlNodeTag nodeTag)
{
if (nodeTag.IsSelfClosing || Options.IsAutoClosingTag(nodeTag.TagName))
ClassBuilder.AppendSelfClosingTagSuffix();
else
{
ClassBuilder.Append(">");
base.Walk(nodeTag);
if (IsPreCloseTagWhitespaceTrimmed(nodeTag))
{
ClassBuilder.AppendFormat("</{0}>", nodeTag.NamespaceQualifiedTagName);
}
else
{
ClassBuilder.AppendNewLine();
ClassBuilder.AppendFormat(nodeTag.Indent + "</{0}>", nodeTag.NamespaceQualifiedTagName);
}
}
}
public void Walk_NestedTags_AppendsCorrectTags()
{
// Arrange
const string tagName = "p";
const string nestedText = "Hello world";
var tagNode = new HamlNodeTag(new HamlLine(tagName, HamlRuleEnum.Tag, "", 0));
tagNode.AddChild(new HamlNodeTextContainer(new HamlLine(nestedText, HamlRuleEnum.PlainText, "", 1, true)));
// Act
_tagWalker.Walk(tagNode);
// Assert
string expectedTag = string.Format("<{0}>{1}</{0}>", tagName, nestedText);
Assert.That(_classBuilderMock.Build(""), Is.EqualTo(expectedTag));
}
