Renamed all BsonJsonXyz classes to JsonXyz. It was just too awkward the way it was!

Bson/Bson.csproj

@@ -86,11 +86,11 @@
     <Compile Include="IO\BsonDocumentReader.cs" />
     <Compile Include="IO\BsonDocumentReaderBookmark.cs" />
     <Compile Include="IO\BsonDocumentReaderContext.cs" />
-    <Compile Include="IO\BsonJsonBuffer.cs" />
-    <Compile Include="IO\BsonJsonReader.cs" />
-    <Compile Include="IO\BsonJsonReaderBookmark.cs" />
-    <Compile Include="IO\BsonJsonReaderContext.cs" />
-    <Compile Include="IO\BsonJsonScanner.cs" />
+    <Compile Include="IO\JsonBuffer.cs" />
+    <Compile Include="IO\JsonReader.cs" />
+    <Compile Include="IO\JsonReaderBookmark.cs" />
+    <Compile Include="IO\JsonReaderContext.cs" />
+    <Compile Include="IO\JsonScanner.cs" />
     <Compile Include="IO\BsonReaderBookmark.cs" />
     <Compile Include="Serialization\IBsonSerializationOptions.cs" />
     <Compile Include="Serialization\IdGenerators.cs" />
@@ -131,9 +131,9 @@
     <Compile Include="IO\BsonBinaryReader.cs" />
     <Compile Include="IO\BsonBinaryReaderSettings.cs" />
     <Compile Include="BsonDefaults.cs" />
-    <Compile Include="IO\BsonJsonOutputMode.cs" />
-    <Compile Include="IO\BsonJsonWriter.cs" />
-    <Compile Include="IO\BsonJsonWriterSettings.cs" />
+    <Compile Include="IO\JsonOutputMode.cs" />
+    <Compile Include="IO\JsonWriter.cs" />
+    <Compile Include="IO\JsonWriterSettings.cs" />
     <Compile Include="ObjectModel\BsonBoolean.cs" />
     <Compile Include="ObjectModel\BsonDateTime.cs" />
     <Compile Include="ObjectModel\BsonDocumentWrapper.cs" />
@@ -178,7 +178,7 @@
     <Compile Include="Serialization\IIdGenerator.cs" />
     <Compile Include="Serialization\IBsonSerializable.cs" />
     <Compile Include="Serialization\IBsonSerializer.cs" />
-    <Compile Include="IO\BsonJsonWriterContext.cs" />
+    <Compile Include="IO\JsonWriterContext.cs" />
     <Compile Include="IO\BsonBinaryReaderContext.cs" />
     <Compile Include="IO\BsonBinaryWriterContext.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

Bson/BsonExtensionMethods.cs

@@ -90,20 +90,20 @@ namespace MongoDB.Bson {
         public static string ToJson<T>(
             this T obj
         ) {
-            return ToJson(obj, BsonJsonWriterSettings.Defaults);
+            return ToJson(obj, JsonWriterSettings.Defaults);
         }
 
         public static string ToJson<T>(
             this T obj,
             IBsonSerializationOptions options
         ) {
-            return ToJson(obj, options, BsonJsonWriterSettings.Defaults);
+            return ToJson(obj, options, JsonWriterSettings.Defaults);
         }
 
         public static string ToJson<T>(
             this T obj,
             IBsonSerializationOptions options,
-            BsonJsonWriterSettings settings
+            JsonWriterSettings settings
         ) {
             using (var stringWriter = new StringWriter()) {
                 using (var bsonWriter = BsonWriter.Create(stringWriter, settings)) {
@@ -115,7 +115,7 @@ namespace MongoDB.Bson {
 
         public static string ToJson<T>(
             this T obj,
-            BsonJsonWriterSettings settings
+            JsonWriterSettings settings
         ) {
             return ToJson(obj, null, settings);
         }

Bson/IO/BsonReader.cs

@@ -52,9 +52,9 @@ namespace MongoDB.Bson.IO {
         }
 
         public static BsonReader Create(
-            BsonJsonBuffer buffer
+            JsonBuffer buffer
         ) {
-            return new BsonJsonReader(buffer);
+            return new JsonReader(buffer);
         }
 
         public static BsonReader Create(
@@ -75,14 +75,14 @@ namespace MongoDB.Bson.IO {
         public static BsonReader Create(
             string json
         ) {
-            var buffer = new BsonJsonBuffer(json);
+            var buffer = new JsonBuffer(json);
             return Create(buffer);
         }
 
         public static BsonReader Create(
-            TextReader jsonTextReader
+            TextReader textReader
         ) {
-            var json = new BsonJsonBuffer(jsonTextReader.ReadToEnd());
+            var json = textReader.ReadToEnd();
             return Create(json);
         }
         #endregion

Bson/IO/BsonWriter.cs

@@ -64,14 +64,14 @@ namespace MongoDB.Bson.IO {
         public static BsonWriter Create(
             TextWriter writer
         ) {
-            return new BsonJsonWriter(writer, BsonJsonWriterSettings.Defaults);
+            return new JsonWriter(writer, JsonWriterSettings.Defaults);
         }
 
         public static BsonWriter Create(
             TextWriter writer,
-            BsonJsonWriterSettings settings
+            JsonWriterSettings settings
         ) {
-            return new BsonJsonWriter(writer, settings);
+            return new JsonWriter(writer, settings);
         }
         #endregion
 

Bson/IO/BsonJsonBuffer.cs → Bson/IO/JsonBuffer.cs

@@ -19,14 +19,14 @@ using System.Linq;
 using System.Text;
 
 namespace MongoDB.Bson.IO {
-    public class BsonJsonBuffer {
+    public class JsonBuffer {
         #region private fields
         private string buffer;
         private int position;
         #endregion
 
         #region constructors
-        public BsonJsonBuffer(
+        public JsonBuffer(
             string buffer
         ) {
             this.buffer = buffer;

Bson/IO/BsonJsonOutputMode.cs → Bson/IO/JsonOutputMode.cs

@@ -19,7 +19,7 @@ using System.Linq;
 using System.Text;
 
 namespace MongoDB.Bson.IO {
-    public enum BsonJsonOutputMode {
+    public enum JsonOutputMode {
         Strict,
         JavaScript,
         TenGen

Bson/IO/BsonJsonReader.cs → Bson/IO/JsonReader.cs

@@ -21,21 +21,21 @@ using System.Text;
 using System.Xml;
 
 namespace MongoDB.Bson.IO {
-    public class BsonJsonReader : BsonBaseReader {
+    public class JsonReader : BsonBaseReader {
         #region private fields
-        private BsonJsonBuffer buffer;
-        private BsonJsonReaderContext context;
+        private JsonBuffer buffer;
+        private JsonReaderContext context;
         private JsonToken currentToken;
         private BsonValue currentValue; // used for extended JSON
         private JsonToken pushedToken;
         #endregion
 
         #region constructors
-        public BsonJsonReader(
-            BsonJsonBuffer buffer
+        public JsonReader(
+            JsonBuffer buffer
         ) {
             this.buffer = buffer;
-            this.context = new BsonJsonReaderContext(null, ContextType.TopLevel);
+            this.context = new JsonReaderContext(null, ContextType.TopLevel);
         }
         #endregion
 
@@ -48,7 +48,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override BsonReaderBookmark GetBookmark() {
-            return new BsonJsonReaderBookmark(state, currentBsonType, currentName, context, currentToken, currentValue, pushedToken, buffer.Position);
+            return new JsonReaderBookmark(state, currentBsonType, currentName, context, currentToken, currentValue, pushedToken, buffer.Position);
         }
 
         public override void ReadBinaryData(
@@ -246,7 +246,7 @@ namespace MongoDB.Bson.IO {
         public override string ReadJavaScriptWithScope() {
             if (disposed) { ThrowObjectDisposedException(); }
             VerifyBsonType("ReadJavaScriptWithScope", BsonType.JavaScriptWithScope);
-            context = new BsonJsonReaderContext(context, ContextType.JavaScriptWithScope);
+            context = new JsonReaderContext(context, ContextType.JavaScriptWithScope);
             state = BsonReaderState.ScopeDocument;
             return currentValue.AsString;
         }
@@ -301,7 +301,7 @@ namespace MongoDB.Bson.IO {
             if (disposed) { ThrowObjectDisposedException(); }
             VerifyBsonType("ReadStartArray", BsonType.Array);
 
-            context = new BsonJsonReaderContext(context, ContextType.Array);
+            context = new JsonReaderContext(context, ContextType.Array);
             state = BsonReaderState.Type;
         }
 
@@ -309,7 +309,7 @@ namespace MongoDB.Bson.IO {
             if (disposed) { ThrowObjectDisposedException(); }
             VerifyBsonType("ReadStartDocument", BsonType.Document);
 
-            context = new BsonJsonReaderContext(context, ContextType.Document);
+            context = new JsonReaderContext(context, ContextType.Document);
             state = BsonReaderState.Type;
         }
 
@@ -338,7 +338,7 @@ namespace MongoDB.Bson.IO {
         public override void ReturnToBookmark(
             BsonReaderBookmark bookmark
         ) {
-            var jsonReaderBookmark = (BsonJsonReaderBookmark) bookmark;
+            var jsonReaderBookmark = (JsonReaderBookmark) bookmark;
             state = jsonReaderBookmark.State;
             currentBsonType = jsonReaderBookmark.CurrentBsonType;
             currentName = jsonReaderBookmark.CurrentName;
@@ -633,7 +633,7 @@ namespace MongoDB.Bson.IO {
                 pushedToken = null;
                 return token;
             } else {
-                return BsonJsonScanner.GetNextToken(buffer);
+                return JsonScanner.GetNextToken(buffer);
             }
         }
 

Bson/io/BsonJsonReaderBookmark.cs → Bson/IO/JsonReaderBookmark.cs

@@ -19,9 +19,9 @@ using System.Linq;
 using System.Text;
 
 namespace MongoDB.Bson.IO {
-    public class BsonJsonReaderBookmark : BsonReaderBookmark {
+    public class JsonReaderBookmark : BsonReaderBookmark {
         #region private fields
-        private BsonJsonReaderContext context;
+        private JsonReaderContext context;
         private JsonToken currentToken;
         private BsonValue currentValue;
         private JsonToken pushedToken;
@@ -29,11 +29,11 @@ namespace MongoDB.Bson.IO {
         #endregion
 
         #region constructors
-        internal BsonJsonReaderBookmark(
+        internal JsonReaderBookmark(
             BsonReaderState state,
             BsonType currentBsonType,
             string currentName,
-            BsonJsonReaderContext context,
+            JsonReaderContext context,
             JsonToken currentToken,
             BsonValue currentValue,
             JsonToken pushedToken,
@@ -49,7 +49,7 @@ namespace MongoDB.Bson.IO {
         #endregion
 
         #region internal properties
-        internal BsonJsonReaderContext Context {
+        internal JsonReaderContext Context {
             get { return context; }
         }
 

Bson/io/BsonJsonReaderContext.cs → Bson/IO/JsonReaderContext.cs

@@ -20,19 +20,19 @@ using System.Linq;
 using System.Text;
 
 namespace MongoDB.Bson.IO {
-    internal class BsonJsonReaderContext {
+    internal class JsonReaderContext {
         #region private fields
-        private BsonJsonReaderContext parentContext;
+        private JsonReaderContext parentContext;
         private ContextType contextType;
         #endregion
 
         #region constructors
         // used by Clone
-        private BsonJsonReaderContext() {
+        private JsonReaderContext() {
         }
 
-        internal BsonJsonReaderContext(
-            BsonJsonReaderContext parentContext,
+        internal JsonReaderContext(
+            JsonReaderContext parentContext,
             ContextType contextType
         ) {
             this.parentContext = parentContext;
@@ -47,14 +47,14 @@ namespace MongoDB.Bson.IO {
         #endregion
 
         #region public methods
-        public BsonJsonReaderContext Clone() {
-            var clone = new BsonJsonReaderContext();
+        public JsonReaderContext Clone() {
+            var clone = new JsonReaderContext();
             clone.parentContext = this.parentContext;
             clone.contextType = this.contextType;
             return clone;
         }
 
-        public BsonJsonReaderContext PopContext() {
+        public JsonReaderContext PopContext() {
             return parentContext;
         }
         #endregion

Bson/IO/BsonJsonScanner.cs → Bson/IO/JsonScanner.cs

@@ -76,10 +76,10 @@ namespace MongoDB.Bson.IO {
         }
     }
 
-    public static class BsonJsonScanner {
+    public static class JsonScanner {
         #region public static methods
         public static JsonToken GetNextToken(
-            BsonJsonBuffer buffer
+            JsonBuffer buffer
         ) {
             // skip leading whitespace
             var c = buffer.Read();
@@ -116,7 +116,7 @@ namespace MongoDB.Bson.IO {
         #region private methods
         private static string FormatMessage(
             string message,
-            BsonJsonBuffer buffer,
+            JsonBuffer buffer,
             int start
         ) {
             var length = 20;
@@ -130,7 +130,7 @@ namespace MongoDB.Bson.IO {
         }
 
         private static JsonToken GetNumberToken(
-            BsonJsonBuffer buffer,
+            JsonBuffer buffer,
             int c // first character
         ) {
             // leading digit or '-' has already been read
@@ -296,7 +296,7 @@ namespace MongoDB.Bson.IO {
         }
 
         private static JsonToken GetRegularExpressionToken(
-            BsonJsonBuffer buffer
+            JsonBuffer buffer
         ) {
             // opening slash has already been read
             var start = buffer.Position - 1;
@@ -350,7 +350,7 @@ namespace MongoDB.Bson.IO {
         }
 
         private static JsonToken GetStringToken(
-            BsonJsonBuffer buffer
+            JsonBuffer buffer
         ) {
             // opening quote has already been read
             var start = buffer.Position - 1;
@@ -403,7 +403,7 @@ namespace MongoDB.Bson.IO {
         }
 
         private static JsonToken GetUnquotedStringToken(
-            BsonJsonBuffer buffer
+            JsonBuffer buffer
         ) {
             // opening letter or $ has already been read
             var start = buffer.Position - 1;

Bson/IO/BsonJsonWriter.cs → Bson/IO/JsonWriter.cs

@@ -22,21 +22,21 @@ using System.Text;
 using System.Xml;
 
 namespace MongoDB.Bson.IO {
-    public class BsonJsonWriter : BsonBaseWriter {
+    public class JsonWriter : BsonBaseWriter {
         #region private fields
         private TextWriter textWriter;
-        private BsonJsonWriterSettings settings;
-        private BsonJsonWriterContext context;
+        private JsonWriterSettings settings;
+        private JsonWriterContext context;
         #endregion
 
         #region constructors
-        public BsonJsonWriter(
+        public JsonWriter(
             TextWriter writer,
-            BsonJsonWriterSettings settings
+            JsonWriterSettings settings
         ) {
             this.textWriter = writer;
             this.settings = settings;
-            context = new BsonJsonWriterContext(null, ContextType.TopLevel, "");
+            context = new JsonWriterContext(null, ContextType.TopLevel, "");
             state = BsonWriterState.Initial;
         }
         #endregion
@@ -55,7 +55,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override void Flush() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             textWriter.Flush();
         }
 
@@ -63,7 +63,7 @@ namespace MongoDB.Bson.IO {
             byte[] bytes,
             BsonBinarySubType subType
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteBinaryData cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -80,7 +80,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteBoolean(
             bool value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteBoolean cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -95,7 +95,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteDateTime(
             DateTime value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteDateTime cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -107,18 +107,18 @@ namespace MongoDB.Bson.IO {
 
             long milliseconds = (long) Math.Floor((value.ToUniversalTime() - BsonConstants.UnixEpoch).TotalMilliseconds);
             switch (settings.OutputMode) {
-                case BsonJsonOutputMode.Strict:
+                case JsonOutputMode.Strict:
                     WriteStartDocument();
                     WriteInt64("$date", milliseconds);
                     WriteEndDocument();
                     break;
-                case BsonJsonOutputMode.JavaScript:
-                case BsonJsonOutputMode.TenGen:
+                case JsonOutputMode.JavaScript:
+                case JsonOutputMode.TenGen:
                     WriteNameHelper(name);
                     textWriter.Write("Date({0})", milliseconds);
                     break;
                 default:
-                    throw new BsonInternalException("Unexpected BsonJsonOutputMode");
+                    throw new BsonInternalException("Unexpected JsonOutputMode");
             }
 
             state = GetNextState();
@@ -127,7 +127,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteDouble(
             double value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteDouble cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -140,7 +140,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override void WriteEndArray() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value) {
                 var message = string.Format("WriteEndArray cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -153,7 +153,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override void WriteEndDocument() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Name) {
                 var message = string.Format("WriteEndDocument cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -186,7 +186,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteInt32(
             int value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteInt32 cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -201,7 +201,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteInt64(
             long value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteInt64 cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -216,7 +216,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteJavaScript(
             string code
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteJavaScript cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -232,7 +232,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteJavaScriptWithScope(
             string code
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteJavaScriptWithScope cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -246,7 +246,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override void WriteMaxKey() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteMaxKey cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -260,7 +260,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override void WriteMinKey() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteMinKey cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -274,7 +274,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override void WriteNull() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteNull cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -292,7 +292,7 @@ namespace MongoDB.Bson.IO {
             short pid,
             int increment
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteObjectId cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -300,13 +300,13 @@ namespace MongoDB.Bson.IO {
 
             var bytes = ObjectId.Pack(timestamp, machine, pid, increment);
             switch (settings.OutputMode) {
-                case BsonJsonOutputMode.Strict:
-                case BsonJsonOutputMode.JavaScript:
+                case JsonOutputMode.Strict:
+                case JsonOutputMode.JavaScript:
                     WriteStartDocument();
                     WriteString("$oid", BsonUtils.ToHexString(bytes));
                     WriteEndDocument();
                     break;
-                case BsonJsonOutputMode.TenGen:
+                case JsonOutputMode.TenGen:
                     WriteNameHelper(name);
                     textWriter.Write(string.Format("ObjectId(\"{0}\")", BsonUtils.ToHexString(bytes)));
                     break;
@@ -319,21 +319,21 @@ namespace MongoDB.Bson.IO {
             string pattern,
             string options
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteRegularExpression cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
             }
 
             switch (settings.OutputMode) {
-                case BsonJsonOutputMode.Strict:
+                case JsonOutputMode.Strict:
                     WriteStartDocument();
                     WriteString("$regex", pattern);
                     WriteString("$options", options);
                     WriteEndDocument();
                     break;
-                case BsonJsonOutputMode.JavaScript:
-                case BsonJsonOutputMode.TenGen:
+                case JsonOutputMode.JavaScript:
+                case JsonOutputMode.TenGen:
                     WriteNameHelper(name);
                     textWriter.Write("/");
                     textWriter.Write(pattern.Replace(@"\", @"\\"));
@@ -354,7 +354,7 @@ namespace MongoDB.Bson.IO {
         }
 
         public override void WriteStartArray() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteStartArray cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -363,12 +363,12 @@ namespace MongoDB.Bson.IO {
             WriteNameHelper(name);
             textWriter.Write("[");
 
-            context = new BsonJsonWriterContext(context, ContextType.Array, settings.IndentChars);
+            context = new JsonWriterContext(context, ContextType.Array, settings.IndentChars);
             state = BsonWriterState.Value;
         }
 
         public override void WriteStartDocument() {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial && state != BsonWriterState.ScopeDocument) {
                 var message = string.Format("WriteStartDocument cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -380,14 +380,14 @@ namespace MongoDB.Bson.IO {
             textWriter.Write("{");
 
             var contextType = (state == BsonWriterState.ScopeDocument) ? ContextType.ScopeDocument : ContextType.Document;
-            context = new BsonJsonWriterContext(context, contextType, settings.IndentChars);
+            context = new JsonWriterContext(context, contextType, settings.IndentChars);
             state = BsonWriterState.Name;
         }
 
         public override void WriteString(
             string value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteString cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -402,7 +402,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteSymbol(
             string value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteSymbol cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);
@@ -418,7 +418,7 @@ namespace MongoDB.Bson.IO {
         public override void WriteTimestamp(
             long value
         ) {
-            if (disposed) { throw new ObjectDisposedException("BsonJsonWriter"); }
+            if (disposed) { throw new ObjectDisposedException("JsonWriter"); }
             if (state != BsonWriterState.Value && state != BsonWriterState.Initial) {
                 var message = string.Format("WriteTimestamp cannot be called when State is: {0}", state);
                 throw new InvalidOperationException(message);

Bson/IO/BsonJsonWriterContext.cs → Bson/IO/JsonWriterContext.cs

@@ -20,17 +20,17 @@ using System.Linq;
 using System.Text;
 
 namespace MongoDB.Bson.IO {
-    internal class BsonJsonWriterContext {
+    internal class JsonWriterContext {
         #region private fields
-        private BsonJsonWriterContext parentContext;
+        private JsonWriterContext parentContext;
         private ContextType contextType;
         private string indentation;
         private bool hasElements = false;
         #endregion
 
         #region constructors
-        internal BsonJsonWriterContext(
-            BsonJsonWriterContext parentContext,
+        internal JsonWriterContext(
+            JsonWriterContext parentContext,
             ContextType contextType,
             string indentChars
         ) {
@@ -41,7 +41,7 @@ namespace MongoDB.Bson.IO {
         #endregion
 
         #region internal properties
-        internal BsonJsonWriterContext ParentContext {
+        internal JsonWriterContext ParentContext {
             get { return parentContext; }
         }
 

Bson/IO/BsonJsonWriterSettings.cs → Bson/IO/JsonWriterSettings.cs

@@ -20,9 +20,9 @@ using System.Text;
 
 namespace MongoDB.Bson.IO {
     [Serializable]
-    public class BsonJsonWriterSettings {
+    public class JsonWriterSettings {
         #region private static fields
-        private static BsonJsonWriterSettings defaults = new BsonJsonWriterSettings();
+        private static JsonWriterSettings defaults = new JsonWriterSettings();
         #endregion
 
         #region private fields
@@ -31,16 +31,16 @@ namespace MongoDB.Bson.IO {
         private bool indent = false;
         private string indentChars = "  ";
         private string newLineChars = "\r\n";
-        private BsonJsonOutputMode outputMode = BsonJsonOutputMode.Strict;
+        private JsonOutputMode outputMode = JsonOutputMode.Strict;
         #endregion
 
         #region constructors
-        public BsonJsonWriterSettings() {
+        public JsonWriterSettings() {
         }
         #endregion
 
         #region public static properties
-        public static BsonJsonWriterSettings Defaults {
+        public static JsonWriterSettings Defaults {
             get { return defaults; } // TODO: clone?
         }
         #endregion
@@ -71,7 +71,7 @@ namespace MongoDB.Bson.IO {
             set { newLineChars = value; }
         }
 
-        public BsonJsonOutputMode OutputMode {
+        public JsonOutputMode OutputMode {
             get { return outputMode; }
             set { outputMode = value; }
         }

Bson/Serialization/BsonSerializer.cs

@@ -58,7 +58,7 @@ namespace MongoDB.Bson.Serialization {
         }
 
         public static T Deserialize<T>(
-            BsonJsonBuffer buffer
+            JsonBuffer buffer
         ) {
             return (T) Deserialize(buffer, typeof(T));
         }
@@ -101,7 +101,7 @@ namespace MongoDB.Bson.Serialization {
         }
 
         public static object Deserialize(
-            BsonJsonBuffer buffer,
+            JsonBuffer buffer,
             Type nominalType
         ) {
             using (var bsonReader = BsonReader.Create(buffer)) {

BsonUnitTests/BsonUnitTests.csproj

@@ -99,8 +99,8 @@
     <Compile Include="DefaultSerializer\Serializers\StructSerializerTests.cs" />
     <Compile Include="IO\BsonBufferValueStraddlesChunksTests.cs" />
     <Compile Include="IO\BsonDocumentReaderTests.cs" />
-    <Compile Include="IO\BsonJsonReaderTests.cs" />
-    <Compile Include="IO\BsonJsonScannerTests.cs" />
+    <Compile Include="IO\JsonReaderTests.cs" />
+    <Compile Include="IO\JsonScannerTests.cs" />
     <Compile Include="Jira\CSharp102Tests.cs" />
     <Compile Include="Jira\CSharp104Tests.cs" />
     <Compile Include="Jira\CSharp116Tests.cs" />
@@ -118,7 +118,7 @@
     <Compile Include="ObjectModel\BsonDocumentTests.cs" />
     <Compile Include="ObjectModel\BsonElementTests.cs" />
     <Compile Include="ObjectModel\BsonEqualsTests.cs" />
-    <Compile Include="IO\BsonJsonWriterTests.cs" />
+    <Compile Include="IO\JsonWriterTests.cs" />
     <Compile Include="ObjectModel\BsonObjectIdTests.cs" />
     <Compile Include="ObjectModel\BsonTypeMapperTests.cs" />
     <Compile Include="ObjectModel\BsonValueTests.cs" />

BsonUnitTests/IO/BsonJsonReaderTests.cs → BsonUnitTests/IO/JsonReaderTests.cs

@@ -26,7 +26,7 @@ using MongoDB.Bson.Serialization;
 
 namespace MongoDB.BsonUnitTests.IO {
     [TestFixture]
-    public class BsonJsonReaderTests {
+    public class JsonReaderTests {
         private BsonReader bsonReader;
 
         [Test]
@@ -404,7 +404,7 @@ namespace MongoDB.BsonUnitTests.IO {
                 Assert.AreEqual("gim", options);
                 Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
             }
-            var tenGen = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.TenGen };
+            var tenGen = new JsonWriterSettings { OutputMode = JsonOutputMode.TenGen };
             Assert.AreEqual(json, BsonSerializer.Deserialize<BsonRegularExpression>(new StringReader(json)).ToJson(tenGen));
         }
 

BsonUnitTests/IO/BsonJsonScannerTests.cs → BsonUnitTests/IO/JsonScannerTests.cs

@@ -25,12 +25,12 @@ using MongoDB.Bson.IO;
 
 namespace MongoDB.BsonUnitTests.IO {
     [TestFixture]
-    public class BsonJsonScannerTests {
+    public class JsonScannerTests {
         [Test]
         public void TestEndOfFile() {
             var json = "\t ";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.EndOfFile, token.Type);
             Assert.AreEqual("<eof>", token.Lexeme);
             Assert.AreEqual(-1, buffer.Read());
@@ -39,8 +39,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestBeginObject() {
             var json = "\t {x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.BeginObject, token.Type);
             Assert.AreEqual("{", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -49,8 +49,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestEndObject() {
             var json = "\t }x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.EndObject, token.Type);
             Assert.AreEqual("}", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -59,8 +59,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestBeginArray() {
             var json = "\t [x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.BeginArray, token.Type);
             Assert.AreEqual("[", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -69,8 +69,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestEndArray() {
             var json = "\t ]x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.EndArray, token.Type);
             Assert.AreEqual("]", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -79,8 +79,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestNameSeparator() {
             var json = "\t :x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Colon, token.Type);
             Assert.AreEqual(":", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -89,8 +89,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestValueSeparator() {
             var json = "\t ,x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Comma, token.Type);
             Assert.AreEqual(",", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -99,8 +99,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestEmptyString() {
             var json = "\t \"\"x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.String, token.Type);
             Assert.AreEqual("", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -109,8 +109,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void Test1CharacterString() {
             var json = "\t \"1\"x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.String, token.Type);
             Assert.AreEqual("1", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -119,8 +119,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void Test2CharacterString() {
             var json = "\t \"12\"x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.String, token.Type);
             Assert.AreEqual("12", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -129,8 +129,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void Test3CharacterString() {
             var json = "\t \"123\"x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.String, token.Type);
             Assert.AreEqual("123", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -139,8 +139,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestEscapeSequences() {
             var json = "\t \"x\\\"\\\\\\/\\b\\f\\n\\r\\t\\u0030y\"x";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.String, token.Type);
             Assert.AreEqual("x\"\\/\b\f\n\r\t0y", token.Lexeme);
             Assert.AreEqual('x', buffer.Read());
@@ -149,8 +149,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestTrue() {
             var json = "\t true,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.UnquotedString, token.Type);
             Assert.AreEqual("true", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -159,8 +159,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestFalse() {
             var json = "\t false,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.UnquotedString, token.Type);
             Assert.AreEqual("false", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -169,8 +169,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestNull() {
             var json = "\t null,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.UnquotedString, token.Type);
             Assert.AreEqual("null", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -179,8 +179,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestUnquotedString() {
             var json = "\t name123:1";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.UnquotedString, token.Type);
             Assert.AreEqual("name123", token.Lexeme);
             Assert.AreEqual(':', buffer.Read());
@@ -189,8 +189,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestZero() {
             var json = "\t 0,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Integer, token.Type);
             Assert.AreEqual("0", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -199,8 +199,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusZero() {
             var json = "\t -0,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Integer, token.Type);
             Assert.AreEqual("-0", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -209,8 +209,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestOne() {
             var json = "\t 1,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Integer, token.Type);
             Assert.AreEqual("1", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -219,8 +219,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusOne() {
             var json = "\t -1,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Integer, token.Type);
             Assert.AreEqual("-1", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -229,8 +229,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestTwelve() {
             var json = "\t 12,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Integer, token.Type);
             Assert.AreEqual("12", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -239,8 +239,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusTwelve() {
             var json = "\t -12,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.Integer, token.Type);
             Assert.AreEqual("-12", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -249,8 +249,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestZeroPointZero() {
             var json = "\t 0.0,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("0.0", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -259,8 +259,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusZeroPointZero() {
             var json = "\t -0.0,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("-0.0", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -269,8 +269,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestZeroExponentOne() {
             var json = "\t 0e1,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("0e1", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -279,8 +279,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusZeroExponentOne() {
             var json = "\t -0e1,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("-0e1", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -289,8 +289,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestZeroExponentMinusOne() {
             var json = "\t 0e-1,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("0e-1", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -299,8 +299,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusZeroExponentMinusOne() {
             var json = "\t -0e-1,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("-0e-1", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -309,8 +309,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestOnePointTwo() {
             var json = "\t 1.2,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("1.2", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -319,8 +319,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusOnePointTwo() {
             var json = "\t -1.2,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("-1.2", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -329,8 +329,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestOneExponentTwelve() {
             var json = "\t 1e12,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("1e12", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -339,8 +339,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusZeroExponentTwelve() {
             var json = "\t -1e12,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("-1e12", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -349,8 +349,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestOneExponentMinuesTwelve() {
             var json = "\t 1e-12,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("1e-12", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -359,8 +359,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestMinusZeroExponentMinusTwelve() {
             var json = "\t -1e-12,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.FloatingPoint, token.Type);
             Assert.AreEqual("-1e-12", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -369,8 +369,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestRegularExpressionEmpty() {
             var json = "\t //,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.RegularExpression, token.Type);
             Assert.AreEqual("//", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -379,8 +379,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestRegularExpressionPattern() {
             var json = "\t /pattern/,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.RegularExpression, token.Type);
             Assert.AreEqual("/pattern/", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());
@@ -389,8 +389,8 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestRegularExpressionPatternAndOptions() {
             var json = "\t /pattern/gim,";
-            var buffer = new BsonJsonBuffer(json);
-            var token = BsonJsonScanner.GetNextToken(buffer);
+            var buffer = new JsonBuffer(json);
+            var token = JsonScanner.GetNextToken(buffer);
             Assert.AreEqual(JsonTokenType.RegularExpression, token.Type);
             Assert.AreEqual("/pattern/gim", token.Lexeme);
             Assert.AreEqual(',', buffer.Read());

BsonUnitTests/IO/BsonJsonWriterTests.cs → BsonUnitTests/IO/JsonWriterTests.cs

@@ -24,7 +24,7 @@ using MongoDB.Bson.IO;
 
 namespace MongoDB.BsonUnitTests.IO {
     [TestFixture]
-    public class BsonJsonWriterTests {
+    public class JsonWriterTests {
         [Test]
         public void TestEmptyDocument() {
             BsonDocument document = new BsonDocument();
@@ -44,7 +44,7 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestIndentedEmptyDocument() {
             BsonDocument document = new BsonDocument();
-            var settings = new BsonJsonWriterSettings { Indent = true };
+            var settings = new JsonWriterSettings { Indent = true };
             string json = document.ToJson(settings);
             string expected = "{ }";
             Assert.AreEqual(expected, json);
@@ -53,7 +53,7 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestIndentedOneElement() {
             BsonDocument document = new BsonDocument() { { "name", "value" } };
-            var settings = new BsonJsonWriterSettings { Indent = true };
+            var settings = new JsonWriterSettings { Indent = true };
             string json = document.ToJson(settings);
             string expected = "{\r\n  \"name\" : \"value\"\r\n}";
             Assert.AreEqual(expected, json);
@@ -62,7 +62,7 @@ namespace MongoDB.BsonUnitTests.IO {
         [Test]
         public void TestIndentedTwoElements() {
             BsonDocument document = new BsonDocument() { { "a", "x" }, { "b", "y" } };
-            var settings = new BsonJsonWriterSettings { Indent = true };
+            var settings = new JsonWriterSettings { Indent = true };
             string json = document.ToJson(settings);
             string expected = "{\r\n  \"a\" : \"x\",\r\n  \"b\" : \"y\"\r\n}";
             Assert.AreEqual(expected, json);
@@ -83,7 +83,7 @@ namespace MongoDB.BsonUnitTests.IO {
             BsonDocument document = new BsonDocument() {
                 { "doc", new BsonDocument { { "a", 1 }, { "b", 2 } } }
             };
-            var settings = new BsonJsonWriterSettings { Indent = true };
+            var settings = new JsonWriterSettings { Indent = true };
             string json = document.ToJson(settings);
             string expected = "{\r\n  \"doc\" : {\r\n    \"a\" : 1,\r\n    \"b\" : 2\r\n  }\r\n}";
             Assert.AreEqual(expected, json);
@@ -106,11 +106,11 @@ namespace MongoDB.BsonUnitTests.IO {
             BsonDocument document = new BsonDocument() {
                 { "date", jan_1_2010 }
             };
-            var settings = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.Strict };
+            var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
             string json = document.ToJson(settings);
         	string expected = "{ \"date\" : { \"$date\" : # } }".Replace("#", expectedValue.ToString());
             Assert.AreEqual(expected, json);
-            settings = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.JavaScript };
+            settings = new JsonWriterSettings { OutputMode = JsonOutputMode.JavaScript };
             json = document.ToJson(settings);
 			expected = "{ \"date\" : Date(#) }".Replace("#", expectedValue.ToString());
             Assert.AreEqual(expected, json);

DriverUnitTests/Builders/QueryBuilderTests.cs

@@ -211,7 +211,7 @@ namespace MongoDB.DriverUnitTests.Builders {
         public void TestRegex() {
             var query = Query.Matches("name", new BsonRegularExpression("acme.*corp", "i"));
             var expected = "{ \"name\" : /acme.*corp/i }";
-            BsonJsonWriterSettings settings = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.JavaScript };
+            JsonWriterSettings settings = new JsonWriterSettings { OutputMode = JsonOutputMode.JavaScript };
             var actual = query.ToJson(settings);
             Assert.AreEqual(expected, actual);
         }
@@ -220,7 +220,7 @@ namespace MongoDB.DriverUnitTests.Builders {
         public void TestNotRegex() {
             var query = Query.Not("name").Matches(new BsonRegularExpression("acme.*corp", "i"));
             var expected = "{ \"name\" : { \"$not\" : /acme.*corp/i } }";
-            BsonJsonWriterSettings settings = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.JavaScript };
+            JsonWriterSettings settings = new JsonWriterSettings { OutputMode = JsonOutputMode.JavaScript };
             var actual = query.ToJson(settings);
             Assert.AreEqual(expected, actual);
         }