Version 0.7.0

Author: milankinen

CHANGELOG.md

@@ -0,0 +1,8 @@
+# Version history
+
+## 0.7.0
+
+* Removed deprecated builder objects `obj` and `arr`
+* Added `toJObject` and `toJArray` methods
+* Fixed `null` rendering to arrays and objects
+* Throw an exception if trying to render `JUndefined`

README.md

@@ -1,6 +1,7 @@
 # Zeison
 
 [![Build Status](https://travis-ci.org/milankinen/zeison.svg?branch=master)](https://travis-ci.org/milankinen/zeison)
+[![codecov.io](http://codecov.io/github/milankinen/zeison/coverage.svg?branch=master)](http://codecov.io/github/milankinen/zeison?branch=master)
 
 Small, fast and easy-to-use JSON library for Scala.
 
@@ -23,7 +24,7 @@ Zeison is extremely lightweight - binaries (including jawn-parser) require under
 
 To use Zeison in you project, add the following line to your `build.sbt`
 
-    libraryDependencies += "org.tsers.zeison" %% "zeison" % "0.6.0"
+    libraryDependencies += "org.tsers.zeison" %% "zeison" % "0.7.0"
 
 All methods and types are inside object `org.tsers.zeison.Zeison` so in order to
 use them in your code, you must add the following import
@@ -103,6 +104,9 @@ val obj = Zeison.toJson(Map(
   "meta"   -> data.meta,
   "primes" -> Seq(1,2,3,5)
 ))
+// or shortcuts for objects and arrays
+val justObj = Zeison.toJObject("foo" -> "bar", "tsers" -> 1)
+val justArr = Zeison.toJArray(1, 2, 3, "tsers", obj)
 
 // immutable field adding
 // .copy(..) works for JSON objects - other types cause runtime exception
@@ -156,3 +160,16 @@ assert(Zeison.render(custom) == s"""{"createdAt":"${toISO8601(now)}"}""")
 assert(custom.createdAt.is[Date])
 assert(custom.createdAt.to[Date] == now)
 ```
+
+## License
+
+MIT
+
+
+## Contributing
+
+Please feel free to leave a pull request to `development` branch. Before leaving
+the pull request, please check that tests are passed by using script
+
+    ./scripts/test 
+    

build.sbt

@@ -3,7 +3,7 @@ import SonatypeKeys._
 sonatypeSettings
 
 name                := "Zeison"
-version             := "0.6.0"
+version             := "0.7.0"
 profileName         := "org.tsers"
 organization        := "org.tsers.zeison"
 scalaVersion        := "2.10.5"

project/plugins.sbt

@@ -1,5 +1,3 @@
-addSbtPlugin("com.github.mpeltonen" % "sbt-idea" % "1.6.0")
-
 addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "0.2.1")
 
 addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.1.0")

scripts/release

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+echo "Release new version to Maven"
+./sbt clean +compile +publishSigned
+./sbt sonatypeRelease
+echo "Done"

scripts/test

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+echo "Run unit tests and create coverage report"
+./sbt clean coverage +test coverageReport

src/main/scala/org/tsers/zeison/Rendering.scala

@@ -117,7 +117,7 @@ private [zeison] object Rendering {
     }
 
     value match {
-      case JUndefined       => new ZeisonException("Can't render JUndefined")
+      case JUndefined       => throw new ZeisonException("Can't render JUndefined")
       case JNull            => sb.append("null")
       case JBoolean(v)      => sb.append(v)
       case num: JNum        => sb.append(num.valueAsString)

src/main/scala/org/tsers/zeison/Zeison.scala

@@ -42,31 +42,9 @@ object Zeison {
 
   def toJson(any: Any): JValue = toJValue(any)
 
-  @deprecated
-  def from(any: Any): JValue = {
-    toJValue(any)
-  }
-
-  @deprecated
-  object obj {
-    def empty = JObject(Map.empty)
-
-    def apply(fields: (String, Any)*): JObject = {
-      val fieldMap = new util.LinkedHashMap[String, JValue](fields.size)
-      fields.foreach { case (key, value) => toJValue(value).toOption.foreach(jVal => fieldMap.put(key, jVal)) }
-      JObject(new FieldMap(fieldMap))
-    }
-  }
-
-  @deprecated
-  object arr {
-    def empty = JArray(Vector.empty)
-
-    def apply(elems: Any*): JArray = {
-      Zeison.from(elems.toIterable).asInstanceOf[JArray]
-    }
-  }
+  def toJObject(fields: (String, Any)*): JObject = toJValue(fields.toMap).asInstanceOf[JObject]
 
+  def toJArray(elems: Any*): JArray = toJValue(elems).asInstanceOf[JArray]
 
   /*
    * JSON rendering
@@ -87,11 +65,20 @@ object Zeison {
     // ATTENTION: this must be overridden because otherwise traversable trait
     // will cause StackOverflowError
     override def toString() = {
-      def className = getClass.getSimpleName
+      def str(value: Any) = s"${getClass.getSimpleName}($value)"
+      def extractNum(num: JNum): Any = {
+        if (num.hasDecimals) num.valueAsDouble else num.valueAsLong
+      }
+
       this match {
-        case JNull      => "JNull"
-        case JUndefined => "JUndefined"
-        case jValue     => className + "(" + valueOf(jValue).getOrElse("<invalid>") + ")"
+        case JNull           => "JNull"
+        case JUndefined      => "JUndefined"
+        case num: JNum       => str(extractNum(num))
+        case JBoolean(value) => str(value)
+        case JString(value)  => str(value)
+        case JObject(value)  => str(value)
+        case JArray(value)   => str(value)
+        case custom: JCustom => str(custom.value)
       }
     }
 
@@ -284,7 +271,7 @@ object Zeison {
 
       override def -(key: String): Map[String, JValue] = {
         val copied = new util.LinkedHashMap[String, JValue](fields)
-        fields.remove(key)
+        copied.remove(key)
         new FieldMap(copied)
       }
     }
@@ -355,33 +342,19 @@ object Zeison {
         case value: Float                  => JDouble(value)
         case value: Double                 => JDouble(value)
         case value: BigDecimal             => JDouble(value.toDouble)
-        case value: java.lang.Float        => JDouble(Float.unbox(value))
-        case value: java.lang.Double       => JDouble(Double.unbox(value))
         case value: Number                 => JInt(value.longValue())
         case value: Char                   => JString(value.toString)
         case value: String                 => JString(value)
-        case f: scala.collection.Map[_,_]  => JObject(f.flatMap { case (k, v) => toJValue(v).toOption.map((k.toString, _)) }.toMap)
-        case elems: col.TraversableOnce[_] => JArray(elems.flatMap(e => toJValue(e).toOption).toVector)
-        case elems: Array[_]               => JArray(elems.flatMap(e => toJValue(e).toOption).toVector)
+        case f: scala.collection.Map[_,_]  => JObject(f.flatMap { case (k, v) => toOption(toJValue(v)).map((k.toString, _)) }.toMap)
+        case elems: col.TraversableOnce[_] => JArray(elems.flatMap(e => toOption(toJValue(e))).toVector)
+        case elems: Array[_]               => JArray(elems.flatMap(e => toOption(toJValue(e))).toVector)
         case value                         => throw new ZeisonException(s"Can't parse value ($value) to JValue")
       }
     }
 
-    def valueOf(jValue: JValue): Option[Any] = {
-      def extractNum(num: JNum): Any = {
-        if (num.hasDecimals) num.valueAsDouble else num.valueAsLong
-      }
-
-      jValue match {
-        case JUndefined      => None
-        case JNull           => Some(null)
-        case JBoolean(value) => Some(value)
-        case num: JNum       => Some(extractNum(num))
-        case JString(value)  => Some(value)
-        case JObject(value)  => Some(value)
-        case JArray(value)   => Some(value)
-        case custom: JCustom => Some(custom.value)
-      }
+    def toOption(jValue: JValue): Option[JValue] = {
+      if (jValue.isDefined) Some(jValue) else None
     }
+
   }
 }

src/test/scala/org/tsers/zeison/ConversionsSpec.scala

@@ -1,5 +1,9 @@
 package org.tsers.zeison
 
+import java.util.Date
+
+import org.tsers.zeison.Zeison.JCustom
+
 class ConversionsSpec extends BaseSpec {
   import Zeison._
 
@@ -21,18 +25,33 @@ class ConversionsSpec extends BaseSpec {
     it("supports integers") {
       json.int should be('int)
       json.int.toInt should equal(123)
+      json.int.toLong should equal(123L)
       json.bool should not be 'int
       intercept[ZeisonException] {
         json.bool.toInt
       }
+      intercept[ZeisonException] {
+        json.dbl.toInt
+      }
+      intercept[ZeisonException] {
+        json.dbl.toLong
+      }
+      intercept[ZeisonException] {
+        JDouble(1.2).toInt
+      }
+      intercept[ZeisonException] {
+        JDouble(1.2).toLong
+      }
     }
 
     it("supports doubles") {
       json.dbl should be('double)
       json.dbl.toDouble should equal(123.3)
+      json.int.toDouble should equal(123.0)
+      JInt(1).toDouble should equal(1.0)
       json.bool should not be 'double
       intercept[ZeisonException] {
-        json.int.toBool
+        json.str.toDouble
       }
     }
 
@@ -74,6 +93,9 @@ class ConversionsSpec extends BaseSpec {
   describe("JSON conversions") {
     it("support object casting to map") {
       json.obj.toMap.mapValues(_.toInt) should equal(Map("foo" -> 1, "bar" -> 2))
+      intercept[ZeisonException] {
+        json.int.toMap
+      }
     }
 
     it("support array casting to seq") {
@@ -93,4 +115,37 @@ class ConversionsSpec extends BaseSpec {
     }
   }
 
+  describe("custom types") {
+    it("can be used to contruct Zeison objects") {
+      val obj = toJObject("custom" -> JTsers(Tsers("foo")))
+      render(obj) should equal("""{"custom":{"tsers"  :  "foo"}}""")
+    }
+
+    it("can be extracted from Zeison objects") {
+      val obj = toJObject("custom" -> JTsers(Tsers("foo")))
+      obj.custom.is[Tsers] should be(true)
+      obj.custom.to[Tsers] should equal(Tsers("foo"))
+    }
+
+    it("can't be cast to other objects") {
+      val obj = toJObject("custom" -> JTsers(Tsers("foo")))
+      obj.custom.is[Date] should be(false)
+      intercept[ZeisonException] {
+        obj.custom.to[Date]
+      }
+    }
+
+    it("can't be extracted from native Zeison objects") {
+      intercept[ZeisonException] {
+        json.str.to[Tsers]
+      }
+    }
+  }
+
 }
+
+case class JTsers(override val value: Tsers) extends JCustom {
+  override def valueAsJson: String = s"""{"tsers"  :  "${value.msg}"}"""
+}
+
+case class Tsers(msg: Any)

src/test/scala/org/tsers/zeison/CustomTypesSpec.scala

@@ -21,13 +21,13 @@ class CustomTypesSpec extends BaseSpec {
   describe("Custom types") {
 
     it("can be be added to built JSON object and rendered correctly") {
-      val json = obj("date" -> JDate(parseDate("2011-11-11 11:11")))
+      val json = toJson(Map("date" -> JDate(parseDate("2011-11-11 11:11"))))
       render(json) should equal("""{"date":"2011-11-11T11:11:00"}""")
     }
 
     it("can be tested from the built JSON") {
       val date = JDate(parseDate("2011-11-11 11:11"))
-      val json = obj("date" -> date, "num" -> 2)
+      val json = toJson(Map("date" -> date, "num" -> 2))
 
       json.date.isInt should equal(false)
       json.date.is[Date] should equal(true)
@@ -37,13 +37,13 @@ class CustomTypesSpec extends BaseSpec {
 
     it("can be extracted from the built JSON") {
       val date = JDate(parseDate("2011-11-11 11:11"))
-      val json = obj("date" -> date)
+      val json = toJson(Map("date" -> date))
 
       json.date.to[Date] should equal(date.value)
     }
 
     it("throw an exception if wrong type is extracted from the built JSON") {
-      val json = obj("date" -> JDate(parseDate("2011-11-11 11:11")))
+      val json = toJson(Map("date" -> JDate(parseDate("2011-11-11 11:11"))))
 
       intercept[ZeisonException] {
         json.date.toInt