Implemented the resolver unittest.

Changed Loader API to be in line with Dumper,
and updated examples, tutorials and docs.

test/src/compare.d

@@ -42,8 +42,8 @@ void testParser(bool verbose, string dataFilename, string canonicalFilename)
  */
 void testLoader(bool verbose, string dataFilename, string canonicalFilename)
 {
-    auto data = loadAll(dataFilename);
-    auto canonical = loadAll(canonicalFilename);
+    auto data = Loader(dataFilename).loadAll;
+    auto canonical = Loader(canonicalFilename).loadAll;
 
     assert(data.length == canonical.length, "Unequal node count");
     foreach(n; 0 .. data.length)

test/src/constructor.d

@@ -398,8 +398,9 @@ void testConstructor(bool verbose, string dataFilename, string codeDummy)
     constructor.addConstructor("!tag1", &constructClass);
     constructor.addConstructor("!tag2", &constructStruct);
 
-    auto resolver = new Resolver;
-    auto loader   = Loader(dataFilename, constructor, resolver);
+    auto loader        = Loader(dataFilename);
+    loader.constructor = constructor;
+    loader.resolver    = new Resolver;
 
     Node[] exp = expected[base];
 

test/src/emitter.d

@@ -92,8 +92,12 @@ void testEmitterOnData(bool verbose, string dataFilename, string canonicalFilena
         writeln("ORIGINAL:\n", readText(dataFilename));
         writeln("OUTPUT:\n", cast(string)emitStream.data);
     }
-    auto loadStream = new MemoryStream(emitStream.data);
-    auto newEvents = Loader(loadStream, "DUMMY", new Constructor, new Resolver).parse();
+
+    auto loader2        = Loader(new MemoryStream(emitStream.data));
+    loader2.name        = "TEST";
+    loader2.constructor = new Constructor;
+    loader2.resolver    = new Resolver;
+    auto newEvents = loader2.parse();
     assert(compareEvents(events, newEvents));
 }
 
@@ -121,8 +125,11 @@ void testEmitterOnCanonical(bool verbose, string canonicalFilename)
             writeln("OUTPUT (canonical=", canonical, "):\n", 
                     cast(string)emitStream.data);
         }
-        auto loadStream = new MemoryStream(emitStream.data);
-        auto newEvents = Loader(loadStream, "DUMMY", new Constructor, new Resolver).parse();
+        auto loader2        = Loader(new MemoryStream(emitStream.data));
+        loader2.name        = "TEST";
+        loader2.constructor = new Constructor;
+        loader2.resolver    = new Resolver;
+        auto newEvents = loader2.parse();
         assert(compareEvents(events, newEvents));
     }
 }
@@ -179,8 +186,11 @@ void testEmitterStyles(bool verbose, string dataFilename, string canonicalFilena
                             to!string(style), ")");
                     writeln(emitStream.data);
                 }
-                auto loadStream = new MemoryStream(emitStream.data);
-                auto newEvents = Loader(loadStream, "DUMMY", new Constructor, new Resolver).parse();
+                auto loader2        = Loader(new MemoryStream(emitStream.data));
+                loader2.name        = "TEST";
+                loader2.constructor = new Constructor;
+                loader2.resolver    = new Resolver;
+                auto newEvents = loader2.parse();
                 assert(compareEvents(events, newEvents));
             }
         }

test/src/errors.d

@@ -22,7 +22,7 @@ void testLoaderError(bool verbose, string errorFilename)
     scope(exit){file.close();}
 
     Node[] nodes;
-    try{nodes = loadAll(file, errorFilename);}
+    try{nodes = Loader(file).loadAll();}
     catch(YAMLException e)
     {
         if(verbose){writeln(typeid(e).toString(), "\n", e);}
@@ -48,7 +48,7 @@ void testLoaderErrorString(bool verbose, string errorFilename)
 
     try
     {
-        auto nodes = loadAll(new MemoryStream(buffer), errorFilename);
+        auto nodes = Loader(new MemoryStream(buffer)).loadAll();
     }
     catch(YAMLException e)
     {
@@ -66,7 +66,7 @@ void testLoaderErrorString(bool verbose, string errorFilename)
  */
 void testLoaderErrorFilename(bool verbose, string errorFilename)
 {
-    try{auto nodes = loadAll(errorFilename);}
+    try{auto nodes = Loader(errorFilename).loadAll();}
     catch(YAMLException e)
     {
         if(verbose){writeln(typeid(e).toString(), "\n", e);}
@@ -83,7 +83,7 @@ void testLoaderErrorFilename(bool verbose, string errorFilename)
  */
 void testLoaderErrorSingle(bool verbose, string errorFilename)
 {
-    try{auto nodes = load(errorFilename);}
+    try{auto nodes = Loader(errorFilename).load();}
     catch(YAMLException e)
     {
         if(verbose){writeln(typeid(e).toString(), "\n", e);}

test/src/inputoutput.d

@@ -57,13 +57,13 @@ void testUnicodeInput(bool verbose, string unicodeFilename)
     string data     = readText(unicodeFilename);
     string expected = data.split().join(" ");
 
-    Node output = load(new MemoryStream(to!(char[])(data)), unicodeFilename);
+    Node output = Loader(new MemoryStream(to!(char[])(data))).load();
     assert(output.get!string == expected);
 
     foreach(stream; [new MemoryStream(cast(byte[])(bom16() ~ to!(wchar[])(data))),
                      new MemoryStream(cast(byte[])(bom32() ~ to!(dchar[])(data)))])    
     {
-        output = load(stream, unicodeFilename); 
+        output = Loader(stream).load();
         assert(output.get!string == expected);
     }
 }
@@ -82,7 +82,7 @@ void testUnicodeInputErrors(bool verbose, string unicodeFilename)
                      new MemoryStream(cast(byte[])(bom16(true) ~ to!(wchar[])(data))),
                      new MemoryStream(cast(byte[])(bom32(true) ~ to!(dchar[])(data)))])
     {
-        try{load(stream, unicodeFilename);}
+        try{Loader(stream).load();}
         catch(YAMLException e)
         {
             if(verbose){writeln(typeid(e).toString(), "\n", e);}

test/src/representer.d

@@ -61,9 +61,10 @@ void testRepresenterTypes(bool verbose, string codeFilename)
         constructor.addConstructor("!tag1", &constructClass);
         constructor.addConstructor("!tag2", &constructStruct);
 
-        auto resolver = new Resolver;
-        auto loader   = Loader(loadStream, "DUMMY", constructor, resolver);
-        foreach(node; loader){readNodes ~= node;}
+        auto loader        = Loader(loadStream);
+        loader.name        = "TEST";
+        loader.constructor = constructor;
+        readNodes          = loader.loadAll();
 
         assert(expectedNodes.length == readNodes.length);
         foreach(n; 0 .. expectedNodes.length)

test/src/resolver.d

@@ -17,27 +17,31 @@ import dyaml.testcommon;
  * Implicit tag resolution unittest.
  *
  * Params:  verbose        = Print verbose output?
- *          dataFilename   = TODO 
- *          detectFilename = TODO
+ *          dataFilename   = File with unittest data.
+ *          detectFilename = Dummy filename used to specify which data filenames to use.
  */
 void testImplicitResolver(bool verbose, string dataFilename, string detectFilename)
 {
     string correctTag;
     Node node;
 
-    scope(exit)
+    scope(failure)
     {
-        if(verbose)
+        if(true)
         {
             writeln("Correct tag: ", correctTag);
             writeln("Node: ", node.debugString);
-            assert(node.isSequence);
-            assert(node.tag.get == correctTag);
         }
     }
 
-    correctTag = readText(dataFilename).strip();
-    node = yaml.load(dataFilename);
+    correctTag = readText(detectFilename).strip();
+    node = Loader(dataFilename).load();
+    assert(node.isSequence);
+    foreach(ref Node scalar; node)
+    {
+        assert(scalar.isScalar);
+        assert(scalar.tag.get == correctTag);
+    }
 }