Пример #1
0
// TestSML2XML checks the conversion from SML to XML.
func TestSML2XML(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	in := `{html
{head {title A test document}}
{body
  {h1:title A test document}
  {p:intro:preface The is a simple sentence with an {em emphasized}
  and a {strong strong} text. We'll see how it renders.}
  {ul
    {li:1 It should be nice.}
    {li:2 It should be error free.}
    {li:3 It should be fast.}
  }
  {!
for foo := 0; foo < 42; foo++ {
	println(foo)
}
  !}
}}`
	builder := sml.NewNodeBuilder()
	err := sml.ReadSML(strings.NewReader(in), builder)
	assert.Nil(err)
	root, err := builder.Root()
	assert.Nil(err)

	buf := bytes.NewBufferString("")
	ctx := sml.NewWriterContext(sml.NewXMLWriter("pre"), buf, true, "    ")
	ctx.Register("li", newLIWriter())
	sml.WriteSML(root, ctx)

	assert.Logf("===== XML =====")
	assert.Logf(buf.String())
	assert.Logf("===== DONE =====")
}
Пример #2
0
// TestNegativeTreeReading checks the failing reading of trees.
func TestNegativeTreeReading(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	text := "{foo {bar 1}{bar 2}}"
	builder := sml.NewKeyStringValueTreeBuilder()
	err := sml.ReadSML(strings.NewReader(text), builder)
	assert.ErrorMatch(err, `.* node has multiple values`)
}
Пример #3
0
// TestNegativeNodeReading checks the failing reading of nodes.
func TestNegativeNodeReading(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	text := "{Foo {bar:1 Yadda {test} {} 1} {bar:2 Yadda 2}}"
	builder := sml.NewNodeBuilder()
	err := sml.ReadSML(strings.NewReader(text), builder)
	assert.ErrorMatch(err, `.* cannot read SML document: invalid character after opening at index .*`)
}
Пример #4
0
// TestPositiveTreeReading checks the successful reading of trees.
func TestPositiveTreeReading(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	text := "{config {foo 1}{bar 2}{yadda {up down}{down up}}}"
	builder := sml.NewKeyStringValueTreeBuilder()
	err := sml.ReadSML(strings.NewReader(text), builder)
	assert.Nil(err)
	tree, err := builder.Tree()
	assert.Nil(err)
	assert.Logf("%v", tree)
}
Пример #5
0
// Read reads the SML source of the configuration from a
// reader, parses it, and returns the configuration instance.
func Read(source io.Reader) (Configuration, error) {
	builder := sml.NewKeyStringValueTreeBuilder()
	err := sml.ReadSML(source, builder)
	if err != nil {
		return nil, errors.Annotate(err, ErrIllegalSourceFormat, errorMessages)
	}
	tree, err := builder.Tree()
	if err != nil {
		return nil, errors.Annotate(err, ErrIllegalSourceFormat, errorMessages)
	}
	if err := tree.At("config").Error(); err != nil {
		return nil, errors.Annotate(err, ErrIllegalSourceFormat, errorMessages)
	}
	return &configuration{tree}, nil
}
Пример #6
0
// TestPositiveNodeReading checks the successful reading of nodes.
func TestPositiveNodeReading(t *testing.T) {
	assert := audit.NewTestingAssertion(t, true)
	text := "Before!   {foo:main {bar:1:first Yadda ^{Test^} 1} {! Raw: }} { ! ^^^ !}  {inbetween}  {bar:2:last Yadda {Test ^^} 2}}   After!"
	builder := sml.NewNodeBuilder()
	err := sml.ReadSML(strings.NewReader(text), builder)
	assert.Nil(err)
	root, err := builder.Root()
	assert.Nil(err)
	assert.Equal(root.Tag(), []string{"foo", "main"})
	assert.NotEmpty(root)

	buf := bytes.NewBufferString("")
	ctx := sml.NewWriterContext(sml.NewStandardSMLWriter(), buf, true, "    ")
	sml.WriteSML(root, ctx)

	assert.Logf("===== PARSED SML =====")
	assert.Logf(buf.String())
	assert.Logf("===== DONE =====")
}