Arrow reformatting

bwmcadams · Mar 10, 2016 · dcf2d75 · dcf2d75
1 parent 21a402c
commit dcf2d75
Show file tree

Hide file tree

Showing 3 changed files with 55 additions and 52 deletions.
diff --git a/bson/src/main/scala/codes/bytes/hammersmith/bson/codecs/BSONCodec.scala b/bson/src/main/scala/codes/bytes/hammersmith/bson/codecs/BSONCodec.scala
@@ -77,7 +77,7 @@ object BSONCodec extends StrictLogging {
      * @see http://bsonspec.org
      */
     val bsonString: Codec[BSONString] =
-      logToStdOut(variableSizeBytes(int32L, string(Charset.forName("UTF-8")), 1).as[BSONString], "~~~~ STRING DECODE: ")
+      variableSizeBytes(int32L, string(Charset.forName("UTF-8")), 1).as[BSONString]
 
     /**
      * BSON Binary Subtype for “Generic” binary.
@@ -198,85 +198,85 @@ object BSONCodec extends StrictLogging {
           case _ ⇒ None
         } (cstring ~ bsonDouble).
         subcaseO(BSONString.typeCode) {
-          case (nme, fld: BSONString) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONString) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonString).
         subcaseO(BSONRawDocument.typeCode) {
-          case (nme, fld: BSONRawDocument) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONRawDocument) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonDocumentCodec).
         subcaseO(BSONRawArray.typeCode) {
-          case (nme, fld: BSONRawArray) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONRawArray) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonArrayCodec).
         subcaseO(BSONBinary.typeCode) {
-          case (nme, fld: BSONBinary) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONBinary) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ variableSizeBytes(bsonSizeBytesHeaderCodec, bsonBinary)).
         // this is really an asymmetric - we decode for posterity but shouldn't encode at AST Level
         subcaseO(BSONUndefined.typeCode) {
-          case (nme, BSONUndefined) => Some(nme -> BSONUndefined)
-          case _ => None
+          case (nme, BSONUndefined) ⇒ Some(nme → BSONUndefined)
+          case _ ⇒ None
         }(cstring ~ provide(BSONUndefined)).
         subcaseO(BSONObjectID.typeCode) {
-          case (nme, fld: BSONObjectID) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONObjectID) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonObjectID).
         subcaseO(BSONBoolean.typeCode) {
-          case (nme, fld: BSONBoolean) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONBoolean) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonBoolean).
         subcaseO(BSONUTCDateTime.typeCode) {
-          case (nme, fld: BSONUTCDateTime) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONUTCDateTime) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonUTCDateTime).
         subcaseO(BSONNull.typeCode) {
-          case (nme, BSONNull) => Some(nme -> BSONNull)
-          case _ => None
+          case (nme, BSONNull) ⇒ Some(nme → BSONNull)
+          case _ ⇒ None
         }(cstring ~ provide(BSONNull)).
         subcaseO(BSONRegex.typeCode) {
-          case (nme, fld: BSONRegex) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONRegex) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonRegex).
         subcaseO(BSONDBPointer.typeCode) {
-          case (nme, fld: BSONDBPointer) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONDBPointer) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonDBPointer).
         subcaseO(BSONJSCode.typeCode) {
-          case (nme, fld: BSONJSCode) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONJSCode) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonJSCode).
         subcaseO(BSONSymbol.typeCode) {
-          case (nme, fld: BSONSymbol) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONSymbol) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonSymbol).
         subcaseO(BSONScopedJSCode.typeCode) {
-          case (nme, fld: BSONScopedJSCode) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONScopedJSCode) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonScopedJSCode).
         subcaseO(BSONInteger.typeCode) {
-          case (nme, fld: BSONInteger) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONInteger) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonInteger).
         subcaseO(BSONTimestamp.typeCode) {
-          case (nme, fld: BSONTimestamp) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONTimestamp) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonTimestamp).
         subcaseO(BSONLong.typeCode) {
-          case (nme, fld: BSONLong) => Some(nme -> fld)
-          case _ => None
+          case (nme, fld: BSONLong) ⇒ Some(nme → fld)
+          case _ ⇒ None
         }(cstring ~ bsonLong).
         subcaseO(255 /* because jvm bytes are signed, 0xff can't be byteified to 255 */ ) {
-          case (nme, BSONMinKey) => Some(nme -> BSONMinKey)
-          case _ => None
+          case (nme, BSONMinKey) ⇒ Some(nme → BSONMinKey)
+          case _ ⇒ None
         }(cstring ~ provide(BSONMinKey)).
         subcaseO(BSONMaxKey.typeCode) {
-          case (nme, BSONMaxKey) => Some(nme -> BSONMaxKey)
-          case _ => None
+          case (nme, BSONMaxKey) ⇒ Some(nme → BSONMaxKey)
+          case _ ⇒ None
         }(cstring ~ provide(BSONMaxKey)).
         subcaseO(BSONEndOfDocument.typeCode) {
-          case (nme, BSONEndOfDocument) => Some(nme -> BSONEndOfDocument)
-          case _ => None
+          case (nme, BSONEndOfDocument) ⇒ Some(nme → BSONEndOfDocument)
+          case _ ⇒ None
         }(provide("") ~ provide(BSONEndOfDocument)),
       "#\t ")
   }
@@ -295,7 +295,7 @@ object BSONCodec extends StrictLogging {
  */
 object BSONOldUUIDCodec extends Codec[BSONBinaryOldUUID] {
 
-  protected val mkUUID: (Long, Long) => BSONBinaryOldUUID = BSONBinaryOldUUID(_, _)
+  protected val mkUUID: (Long, Long) ⇒ BSONBinaryOldUUID = BSONBinaryOldUUID(_, _)
 
   override def encode(u: BSONBinaryOldUUID): Attempt[BitVector] =
     Codec.encodeBoth(int64, int64)(u.leastSignificant, u.mostSignificant)
@@ -311,7 +311,7 @@ object BSONOldUUIDCodec extends Codec[BSONBinaryOldUUID] {
 
 object BSONNewUUIDCodec extends Codec[BSONBinaryUUID] {
 
-  protected val mkUUID: (Long, Long) => BSONBinaryUUID = BSONBinaryUUID(_, _)
+  protected val mkUUID: (Long, Long) ⇒ BSONBinaryUUID = BSONBinaryUUID(_, _)
 
   override def encode(u: BSONBinaryUUID): Attempt[BitVector] =
     Codec.encodeBoth(int64, int64)(u.mostSignificant, u.leastSignificant)

diff --git a/bson/src/main/scala/codes/bytes/hammersmith/bson/types/Types.scala b/bson/src/main/scala/codes/bytes/hammersmith/bson/types/Types.scala
@@ -312,15 +312,15 @@ object BSONBoolean extends BSONTypeCompanion {
 
 
 case object BSONBooleanTrue extends BSONBooleanCompanion with BSONBoolean {
-  val subTypeCode: Byte = 0x00
+  val subTypeCode: Byte = 0x01
   val booleanValue = true
   type Primitive = Boolean
 
   val primitiveValue = true
 }
 
 case object BSONBooleanFalse extends BSONBooleanCompanion with BSONBoolean {
-  val subTypeCode: Byte = 0x01
+  val subTypeCode: Byte = 0x00
   val booleanValue = false
   type Primitive = Boolean
 

diff --git a/bson/src/test/scala/codes/bytes/hammersmith/bson/CodecsSpec.scala b/bson/src/test/scala/codes/bytes/hammersmith/bson/CodecsSpec.scala
@@ -59,9 +59,10 @@ class CodecsSpec extends WordSpec with MustMatchers with OptionValues {
       map.get("long5").value mustBe BSONLong(5)
       map.get("float324_582").value mustBe BSONDouble(324.582f)
       map.get("double245_6289").value mustBe BSONDouble(245.6289)
+      map.get("booleanFalse").value mustBe BSONBooleanFalse
+      map.get("booleanTrue").value mustBe BSONBooleanTrue
     }
     "Not exhibit weird behavior with strings, decoding a doc with just a string cleanly with no remainder" in {
-      import BSONCodec.bsonFieldCodec
       val inBytes = bsonStringEncode
       val inBits = BitVector(inBytes)
       val outDoc = BSONCodec.decode(inBits)
@@ -140,18 +141,20 @@ class CodecsSpec extends WordSpec with MustMatchers with OptionValues {
     b.append("float324_582", 324.582f)
     b.append("double245_6289", 245.6289)
     b.append("oid", testOid)
-    // Code wonky
+    // TODO: Code wonky
     /*b.append("code", testCode)
     b.append("code_scoped", testCodeWScope)*/
     b.append("str", testStr)
-    //b.append("ref", new com.mongodb.DBRef(_db, "testRef", test_ref_id))
+    //b.append("ref", new com.mongodb.DBRef("testRef", "foo"))
     b.append("object", testDoc)
-    /*b.append("array", testList)
-    b.append("binary", testBin)
-    b.append("uuid", testUUID)
+    b.append("array", testList)
+    // TODO: Fix binary
+    //b.append("binary", testBin)
+    // TODO: Fix UUID
+    //b.append("uuid", testUUID)
     b.append("regex", testRE)
     // Symbol wonky in java driver
-    b.append("symbol", testSym)*/
+    b.append("symbol", testSym)
 
     val doc = b.get()