From 3a40842d7b3aeedddb9ab5e8261dd48ea4e024b6 Mon Sep 17 00:00:00 2001 From: Li Haoyi Date: Thu, 14 Dec 2017 21:48:32 -0800 Subject: First pass adding a Jawn build to the test suite. Jawn's own test suite doesn't run properly for some reason --- scalaplugin/src/test/resource/jawn/.gitignore | 20 + scalaplugin/src/test/resource/jawn/.travis.yml | 6 + scalaplugin/src/test/resource/jawn/README.md | 427 +++++++++++++++++ .../jawn/ast/src/main/scala/jawn/ast/JParser.scala | 35 ++ .../jawn/ast/src/main/scala/jawn/ast/JValue.scala | 314 +++++++++++++ .../ast/src/main/scala/jawn/ast/JawnFacade.scala | 51 +++ .../ast/src/main/scala/jawn/ast/Renderer.scala | 101 ++++ .../ast/src/test/scala/jawn/ArbitraryUtil.scala | 49 ++ .../jawn/ast/src/test/scala/jawn/AstTest.scala | 79 ++++ .../jawn/ast/src/test/scala/jawn/ParseCheck.scala | 169 +++++++ .../src/test/resource/jawn/benchmark/build.sbt | 21 + .../src/main/scala/jawn/JmhBenchmarks.scala | 120 +++++ .../benchmark/src/main/scala/jawn/Parboiled.scala | 105 +++++ .../src/main/scala/jawn/ParseLongBench.scala | 133 ++++++ scalaplugin/src/test/resource/jawn/build.sbt | 162 +++++++ .../jawn/parser/src/main/resources/utf8.json | 7 + .../parser/src/main/scala/jawn/AsyncParser.scala | 319 +++++++++++++ .../src/main/scala/jawn/ByteBasedParser.scala | 104 +++++ .../src/main/scala/jawn/ByteBufferParser.scala | 42 ++ .../parser/src/main/scala/jawn/ChannelParser.scala | 164 +++++++ .../src/main/scala/jawn/CharBasedParser.scala | 98 ++++ .../parser/src/main/scala/jawn/CharBuilder.scala | 56 +++ .../src/main/scala/jawn/CharSequenceParser.scala | 18 + .../jawn/parser/src/main/scala/jawn/Facade.scala | 34 ++ .../parser/src/main/scala/jawn/MutableFacade.scala | 35 ++ .../parser/src/main/scala/jawn/NullFacade.scala | 30 ++ .../jawn/parser/src/main/scala/jawn/Parser.scala | 507 +++++++++++++++++++++ .../parser/src/main/scala/jawn/SimpleFacade.scala | 42 ++ .../parser/src/main/scala/jawn/StringParser.scala | 25 + .../parser/src/main/scala/jawn/SupportParser.scala | 31 ++ .../parser/src/main/scala/jawn/SyncParser.scala | 37 ++ .../jawn/parser/src/main/scala/jawn/Syntax.scala | 27 ++ .../parser/src/test/scala/jawn/ChannelSpec.scala | 25 + .../src/test/scala/jawn/CharBuilderSpec.scala | 23 + .../src/test/scala/jawn/JNumIndexCheck.scala | 81 ++++ .../parser/src/test/scala/jawn/SyntaxCheck.scala | 131 ++++++ .../jawn/parser/src/test/scala/jawn/TestUtil.scala | 18 + .../test/resource/jawn/project/ReleaseHelper.scala | 34 ++ .../test/resource/jawn/project/build.properties | 1 + .../src/test/resource/jawn/project/plugins.sbt | 6 + scalaplugin/src/test/resource/jawn/randjson.py | 78 ++++ scalaplugin/src/test/resource/jawn/randjson2.py | 53 +++ .../support/argonaut/src/main/scala/Parser.scala | 45 ++ .../argonaut/src/test/scala/ParserSpec.scala | 41 ++ .../support/json4s/src/main/scala/Parser.scala | 59 +++ .../jawn/support/play/src/main/scala/Parser.scala | 20 + .../support/rojoma-v3/src/main/scala/Parser.scala | 18 + .../support/rojoma/src/main/scala/Parser.scala | 18 + .../jawn/support/spray/src/main/scala/Parser.scala | 17 + .../src/main/scala/jawn/util/InvalidLong.scala | 7 + .../jawn/util/src/main/scala/jawn/util/Slice.scala | 95 ++++ .../util/src/main/scala/jawn/util/package.scala | 96 ++++ .../src/test/scala/jawn/util/ParseLongCheck.scala | 72 +++ .../util/src/test/scala/jawn/util/SliceCheck.scala | 131 ++++++ scalaplugin/src/test/resource/jawn/version.sbt | 1 + .../test/scala/mill/scalaplugin/JawnTests.scala | 91 ++++ 56 files changed, 4529 insertions(+) create mode 100644 scalaplugin/src/test/resource/jawn/.gitignore create mode 100644 scalaplugin/src/test/resource/jawn/.travis.yml create mode 100644 scalaplugin/src/test/resource/jawn/README.md create mode 100644 scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JValue.scala create mode 100644 scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JawnFacade.scala create mode 100644 scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/Renderer.scala create mode 100644 scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ArbitraryUtil.scala create mode 100644 scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/AstTest.scala create mode 100644 scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ParseCheck.scala create mode 100644 scalaplugin/src/test/resource/jawn/benchmark/build.sbt create mode 100644 scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/JmhBenchmarks.scala create mode 100644 scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/Parboiled.scala create mode 100644 scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/ParseLongBench.scala create mode 100644 scalaplugin/src/test/resource/jawn/build.sbt create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/resources/utf8.json create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/AsyncParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBasedParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBufferParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ChannelParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBasedParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBuilder.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharSequenceParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Facade.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/MutableFacade.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/NullFacade.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Parser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SimpleFacade.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/StringParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SupportParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SyncParser.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Syntax.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/ChannelSpec.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/CharBuilderSpec.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/JNumIndexCheck.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/SyntaxCheck.scala create mode 100644 scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/TestUtil.scala create mode 100644 scalaplugin/src/test/resource/jawn/project/ReleaseHelper.scala create mode 100644 scalaplugin/src/test/resource/jawn/project/build.properties create mode 100644 scalaplugin/src/test/resource/jawn/project/plugins.sbt create mode 100644 scalaplugin/src/test/resource/jawn/randjson.py create mode 100644 scalaplugin/src/test/resource/jawn/randjson2.py create mode 100644 scalaplugin/src/test/resource/jawn/support/argonaut/src/main/scala/Parser.scala create mode 100644 scalaplugin/src/test/resource/jawn/support/argonaut/src/test/scala/ParserSpec.scala create mode 100644 scalaplugin/src/test/resource/jawn/support/json4s/src/main/scala/Parser.scala create mode 100644 scalaplugin/src/test/resource/jawn/support/play/src/main/scala/Parser.scala create mode 100644 scalaplugin/src/test/resource/jawn/support/rojoma-v3/src/main/scala/Parser.scala create mode 100644 scalaplugin/src/test/resource/jawn/support/rojoma/src/main/scala/Parser.scala create mode 100644 scalaplugin/src/test/resource/jawn/support/spray/src/main/scala/Parser.scala create mode 100644 scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/InvalidLong.scala create mode 100644 scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/Slice.scala create mode 100644 scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/package.scala create mode 100644 scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/ParseLongCheck.scala create mode 100644 scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/SliceCheck.scala create mode 100644 scalaplugin/src/test/resource/jawn/version.sbt create mode 100644 scalaplugin/src/test/scala/mill/scalaplugin/JawnTests.scala (limited to 'scalaplugin') diff --git a/scalaplugin/src/test/resource/jawn/.gitignore b/scalaplugin/src/test/resource/jawn/.gitignore new file mode 100644 index 00000000..2db3b8c0 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/.gitignore @@ -0,0 +1,20 @@ +lib_managed +project7/boot +project7/plugins/src_managed +project7/plugins/project +project/boot +project/build/target +project/plugins/lib_managed +project/plugins/project +project/plugins/src_managed +project/plugins/target +target +.ensime +.ensime_lucene +TAGS +\#*# +*~ +.#* +.lib +.ensime_cache +.idea diff --git a/scalaplugin/src/test/resource/jawn/.travis.yml b/scalaplugin/src/test/resource/jawn/.travis.yml new file mode 100644 index 00000000..5f9f5fe4 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/.travis.yml @@ -0,0 +1,6 @@ +language: scala +sudo: false +jdk: + - oraclejdk8 +script: + - sbt "so test" diff --git a/scalaplugin/src/test/resource/jawn/README.md b/scalaplugin/src/test/resource/jawn/README.md new file mode 100644 index 00000000..6ea33b92 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/README.md @@ -0,0 +1,427 @@ +## Jawn + +"Jawn is for parsing jay-sawn." + +### Origin + +The term "jawn" comes from the Philadelphia area. It conveys about as +much information as "thing" does. I chose the name because I had moved +to Montreal so I was remembering Philly fondly. Also, there isn't a +better way to describe objects encoded in JSON than "things". Finally, +we get a catchy slogan. + +Jawn was designed to parse JSON into an AST as quickly as possible. + +[![Build Status](https://api.travis-ci.org/non/jawn.svg)](https://travis-ci.org/non/jawn) +[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/non/jawn?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +[![Latest version](https://index.scala-lang.org/non/jawn/jawn-parser/latest.svg?color=orange)](https://index.scala-lang.org/non/jawn/jawn-parser) + +### Overview + +Jawn consists of four parts: + +1. A fast, generic JSON parser (`jawn-parser`) +2. A small, somewhat anemic AST (`jawn-ast`) +3. Support packages which parse to third-party ASTs +4. A few helpful utilities (`jawn-util`) + +Currently Jawn is competitive with the fastest Java JSON libraries +(GSON and Jackson) and in the author's benchmarks it often wins. It +seems to be faster than any other Scala parser that exists (as of July +2014). + +Given the plethora of really nice JSON libraries for Scala, the +expectation is that you're probably here for `jawn-parser` or a +support package. + +### Quick Start + +Jawn supports Scala 2.10, 2.11, and 2.12. + +Here's a `build.sbt` snippet that shows you how to depend on Jawn in +your own SBT project: + +```scala +resolvers += Resolver.sonatypeRepo("releases") + +// use this if you just want jawn's parser, and will implement your own facade +libraryDependencies += "org.spire-math" %% "jawn-parser" % "0.11.0" + +// use this if you want jawn's parser and also jawn's ast +libraryDependencies += "org.spire-math" %% "jawn-ast" % "0.11.0" +``` + +If you want to use Jawn's parser with another project's AST, see the +"Supporting external ASTs with Jawn" section. For example, with Spray +you would say: + +```scala +libraryDependencies += "org.spire-math" %% "jawn-spray" % "0.11.0" +``` + +There are a few reasons you might want to do this: + + * The library's built-in parser is significantly slower than Jawn's. + * Jawn supports more input types (`ByteBuffer`, `File`, etc.). + * You need asynchronous JSON parsing. + +(NOTE: previous to version 0.8.3 the support libraries would have been +named `"spray-support"` instead of `"jawn-spray"`.) + +### Dependencies + +*jawn-parser* has no dependencies other than Scala. + +*jawn-ast* depends on *jawn-parser* but nothing else. + +The various support projects (e.g. *jawn-argonaut*) depend on +the library they are supporting. + +### Parsing + +Jawn's parser is both fast and relatively featureful. Assuming you +want to get back an AST of type `J` and you have a `Facade[J]` +defined, you can use the following `parse` signatures: + +```scala +Parser.parseUnsafe[J](String) → J +Parser.parseFromString[J](String) → Try[J] +Parser.parsefromPath[J](String) → Try[J] +Parser.parseFromFile[J](File) → Try[J] +Parser.parseFromChannel[J](ReadableByteChannel) → Try[J] +Parser.parseFromByteBuffer[J](ByteBuffer) → Try[J] +``` + +Jawn also supports asynchronous parsing, which allows users to feed +the parser with data as it is available. There are three modes: + +* `SingleValue` waits to return a single `J` value once parsing is done. +* `UnwrapArray` if the top-level element is an array, return values as they become available. +* `ValueStream` parse one-or-more json values separated by whitespace. + +Here's an example: + +```scala +import jawn.ast +import jawn.AsyncParser +import jawn.ParseException + +val p = ast.JParser.async(mode = AsyncParser.UnwrapArray) + +def chunks: Stream[String] = ??? +def sink(j: ast.JValue): Unit = ??? + +def loop(st: Stream[String]): Either[ParseException, Unit] = + st match { + case s #:: tail => + p.absorb(s) match { + case Right(js) => + js.foreach(sink) + loop(tail) + case Left(e) => + Left(e) + } + case _ => + p.finish().right.map(_.foreach(sink)) + } + +loop(chunks) +``` + +You can also call `jawn.Parser.async[J]` to use async parsing with an +arbitrary data type (provided you also have an implicit `Facade[J]`). + +### Supporting external ASTs with Jawn + +Jawn currently supports six external ASTs directly: + +| AST | 2.10 | 2.11 | 2.12 | +|-----------|--------|--------|-------| +| Argonaut | 6.2 | 6.2 | 6.2 | +| Json4s | 3.5.2 | 3.5.2 | 3.5.2 | +| Play-json | 2.4.11 | 2.5.15 | 2.6.0 | +| Rojoma | 2.4.3 | 2.4.3 | 2.4.3 | +| Rojoma-v3 | 3.7.2 | 3.7.2 | 3.7.2 | +| Spray | 1.3.3 | 1.3.3 | 1.3.3 | + +Each of these subprojects provides a `Parser` object (an instance of +`SupportParser[J]`) that is parameterized on the given project's +AST (`J`). The following methods are available: + +```scala +Parser.parseUnsafe(String) → J +Parser.parseFromString(String) → Try[J] +Parser.parsefromPath(String) → Try[J] +Parser.parseFromFile(File) → Try[J] +Parser.parseFromChannel(ReadableByteChannel) → Try[J] +Parser.parseFromByteBuffer(ByteBuffer) → Try[J] +``` + +These methods parallel those provided by `jawn.Parser`. + +For the following snippets, `XYZ` is one of (`argonaut`, `json4s`, +`play`, `rojoma`, `rojoma-v3` or `spray`): + +This is how you would include the subproject in build.sbt: + +```scala +resolvers += Resolver.sonatypeRepo("releases") + +libraryDependencies += "org.spire-math" %% jawn-"XYZ" % "0.11.0" +``` + +This is an example of how you might use the parser into your code: + +```scala +import jawn.support.XYZ.Parser + +val myResult = Parser.parseFromString(myString) +``` + +### Do-It-Yourself Parsing + +Jawn supports building any JSON AST you need via type classes. You +benefit from Jawn's fast parser while still using your favorite Scala +JSON library. This mechanism is also what allows Jawn to provide +"support" for other libraries' ASTs. + +To include Jawn's parser in your project, add the following +snippet to your `build.sbt` file: + +```scala +resolvers += Resolver.sonatypeRepo("releases") + +libraryDependencies += "org.spire-math" %% "jawn-parser" % "0.11.0" +``` + +To support your AST of choice, you'll want to define a `Facade[J]` +instance, where the `J` type parameter represents the base of your JSON +AST. For example, here's a facade that supports Spray: + +```scala +import spray.json._ +object Spray extends SimpleFacade[JsValue] { + def jnull() = JsNull + def jfalse() = JsFalse + def jtrue() = JsTrue + def jnum(s: String) = JsNumber(s) + def jint(s: String) = JsNumber(s) + def jstring(s: String) = JsString(s) + def jarray(vs: List[JsValue]) = JsArray(vs) + def jobject(vs: Map[String, JsValue]) = JsObject(vs) +} +``` + +Most ASTs will be easy to define using the `SimpleFacade` or +`MutableFacade` traits. However, if an ASTs object or array instances +do more than just wrap a Scala collection, it may be necessary to +extend `Facade` directly. + +You can also look at the facades used by the support projects to help +you create your own. This could also be useful if you wanted to +use an older version of a supported library. + +### Using the AST + +#### Access + +For accessing atomic values, `JValue` supports two sets of +methods: *get-style* methods and *as-style* methods. + +The *get-style* methods return `Some(_)` when called on a compatible +JSON value (e.g. strings can return `Some[String]`, numbers can return +`Some[Double]`, etc.), and `None` otherwise: + +```scala +getBoolean → Option[Boolean] +getString → Option[String] +getLong → Option[Long] +getDouble → Option[Double] +getBigInt → Option[BigInt] +getBigDecimal → Option[BigDecimal] +``` + +In constrast, the *as-style* methods will either return an unwrapped +value (instead of returning `Some(_)`) or throw an exception (instead +of returning `None`): + +```scala +asBoolean → Boolean // or exception +asString → String // or exception +asLong → Long // or exception +asDouble → Double // or exception +asBigInt → BigInt // or exception +asBigDecimal → BigDecimal // or exception +``` + +To access elements of an array, call `get` with an `Int` position: + +```scala +get(i: Int) → JValue // returns JNull if index is illegal +``` + +To access elements of an object, call `get` with a `String` key: + +```scala +get(k: String) → JValue // returns JNull if key is not found +``` + +Both of these methods also return `JNull` if the value is not the +appropraite container. This allows the caller to chain lookups without +having to check that each level is correct: + +```scala +val v: JValue = ??? + +// returns JNull if a problem is encountered in structure of 'v'. +val t: JValue = v.get("novels").get(0).get("title") + +// if 'v' had the right structure and 't' is JString(s), then Some(s). +// otherwise, None. +val titleOrNone: Option[String] = t.getString + +// equivalent to titleOrNone.getOrElse(throw ...) +val titleOrDie: String = t.asString +``` + +#### Updating + +The atomic values (`JNum`, `JBoolean`, `JNum`, and `JString`) are +immutable. + +Objects are fully-mutable and can have items added, removed, or +changed: + +```scala +set(k: String, v: JValue) → Unit +remove(k: String) → Option[JValue] +``` + +If `set` is called on a non-object, an exception will be thrown. +If `remove` is called on a non-object, `None` will be returned. + +Arrays are semi-mutable. Their values can be changed, but their size +is fixed: + +```scala +set(i: Int, v: JValue) → Unit +``` + +If `set` is called on a non-array, or called with an illegal index, an +exception will be thrown. + +(A future version of Jawn may provide an array whose length can be +changed.) + +### Profiling + +Jawn uses [JMH](http://openjdk.java.net/projects/code-tools/jmh/) +along with the [sbt-jmh](https://github.com/ktoso/sbt-jmh) plugin. + +#### Running Benchmarks + +The benchmarks are located in the `benchmark` project. You can run the +benchmarks by typing `benchmark/run` from SBT. There are many +supported arguments, so here are a few examples: + +Run all benchmarks, with 10 warmups, 10 iterations, using 3 threads: + +`benchmark/run -wi 10 -i 10 -f1 -t3` + +Run just the `CountriesBench` test (5 warmups, 5 iterations, 1 thread): + +`benchmark/run -wi 5 -i 5 -f1 -t1 .*CountriesBench` + +#### Benchmark Issues + +Currently, the benchmarks are a bit fiddily. The most obvious symptom +is that if you compile the benchmarks, make changes, and compile +again, you may see errors like: + +``` +[error] (benchmark/jmh:generateJavaSources) java.lang.NoClassDefFoundError: jawn/benchmark/Bla25Bench +``` + +The fix here is to run `benchmark/clean` and try again. + +You will also see intermittent problems like: + +``` +[error] (benchmark/jmh:compile) java.lang.reflect.MalformedParameterizedTypeException +``` + +The solution here is easier (though frustrating): just try it +again. If you continue to have problems, consider cleaning the project +and trying again. + +(In the future I hope to make the benchmarking here a bit more +resilient. Suggestions and pull requests gladly welcome!) + +#### Files + +The benchmarks use files located in `benchmark/src/main/resources`. If +you want to test your own files (e.g. `mydata.json`), you would: + + * Copy the file to `benchmark/src/main/resources/mydata.json`. + * Add the following code to `JmhBenchmarks.scala`: + +```scala +class MyDataBench extends JmhBenchmarks("mydata.json") +``` + +Jawn has been tested with much larger files, e.g. 100M - 1G, but these +are obviously too large to ship with the project. + +With large files, it's usually easier to comment out most of the +benchmarking methods and only test one (or a few) methods. Some of the +slower JSON parsers get *much* slower for large files. + +#### Interpreting the results + +Remember that the benchmarking results you see will vary based on: + + * Hardware + * Java version + * JSON file size + * JSON file structure + * JSON data values + +I have tried to use each library in the most idiomatic and fastest way +possible (to parse the JSON into a simple AST). Pull requests to +update library versions and improve usage are very welcome. + +### Future Work + +More support libraries could be added. + +It's likely that some of Jawn's I/O could be optimized a bit more, and +also made more configurable. The heuristics around all-at-once loading +versus input chunking could definitely be improved. + +In cases where the user doesn't need fast lookups into JSON objects, +an even lighter AST could be used to improve parsing and rendering +speeds. + +Strategies to cache/intern field names of objects could pay big +dividends in some cases (this might require AST changes). + +If you have ideas for any of these (or other ideas) please feel free +to open an issue or pull request so we can talk about it. + +### Disclaimers + +Jawn only supports UTF-8 when parsing bytes. This might change in the +future, but for now that's the target case. You can always decode your +data to a string, and handle the character set decoding using Java's +standard tools. + +Jawn's AST is intended to be very lightweight and simple. It supports +simple access, and limited mutable updates. It intentionally lacks the +power and sophistication of many other JSON libraries. + +### Copyright and License + +All code is available to you under the MIT license, available at +http://opensource.org/licenses/mit-license.php. + +Copyright Erik Osheim, 2012-2017. diff --git a/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JParser.scala b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JParser.scala new file mode 100644 index 00000000..704557cc --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JParser.scala @@ -0,0 +1,35 @@ +package jawn +package ast + +import java.io.File +import java.nio.ByteBuffer +import java.nio.channels.ReadableByteChannel +import scala.util.Try + +object JParser { + implicit val facade = JawnFacade + + def parseUnsafe(s: String): JValue = + new StringParser(s).parse() + + def parseFromString(s: String): Try[JValue] = + Try(new StringParser[JValue](s).parse) + + def parseFromCharSequence(cs: CharSequence): Try[JValue] = + Try(new CharSequenceParser[JValue](cs).parse) + + def parseFromPath(path: String): Try[JValue] = + parseFromFile(new File(path)) + + def parseFromFile(file: File): Try[JValue] = + Try(ChannelParser.fromFile[JValue](file).parse) + + def parseFromChannel(ch: ReadableByteChannel): Try[JValue] = + Try(ChannelParser.fromChannel(ch).parse) + + def parseFromByteBuffer(buf: ByteBuffer): Try[JValue] = + Try(new ByteBufferParser[JValue](buf).parse) + + def async(mode: AsyncParser.Mode): AsyncParser[JValue] = + AsyncParser(mode) +} diff --git a/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JValue.scala b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JValue.scala new file mode 100644 index 00000000..d09347bc --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JValue.scala @@ -0,0 +1,314 @@ +package jawn +package ast + +import java.lang.Double.{isNaN, isInfinite} +import scala.collection.mutable +import scala.util.hashing.MurmurHash3 + +class WrongValueException(e: String, g: String) extends Exception(s"expected $e, got $g") + +class InvalidNumException(s: String) extends Exception(s"invalid number: $s") + +sealed abstract class JValue { + + def valueType: String + + def getBoolean: Option[Boolean] = None + def getString: Option[String] = None + def getInt: Option[Int] = None + def getLong: Option[Long] = None + def getDouble: Option[Double] = None + def getBigInt: Option[BigInt] = None + def getBigDecimal: Option[BigDecimal] = None + + def asBoolean: Boolean = throw new WrongValueException("boolean", valueType) + def asString: String = throw new WrongValueException("string", valueType) + def asInt: Int = throw new WrongValueException("number", valueType) + def asLong: Long = throw new WrongValueException("number", valueType) + def asDouble: Double = throw new WrongValueException("number", valueType) + def asBigInt: BigInt = throw new WrongValueException("number", valueType) + def asBigDecimal: BigDecimal = throw new WrongValueException("number", valueType) + + def get(i: Int): JValue = JNull + def set(i: Int, v: JValue): Unit = throw new WrongValueException("array", valueType) + + def get(s: String): JValue = JNull + def set(s: String, v: JValue): Unit = throw new WrongValueException("object", valueType) + def remove(s: String): Option[JValue] = None + + final def atomic: Option[JAtom] = + this match { + case v: JAtom => Some(v) + case _ => None + } + + final def isNull: Boolean = + this == JNull + + final def nonNull: Boolean = + this != JNull + + final def render(): String = + CanonicalRenderer.render(this) + + final def render(r: Renderer): String = + r.render(this) + + override def toString: String = + CanonicalRenderer.render(this) +} + +object JValue { + implicit val facade: Facade[JValue] = JawnFacade +} + +sealed abstract class JAtom extends JValue { + def fold[A](f1: String => A, f2: Double => A, f3: Boolean => A, f4: => A): A = + this match { + case JString(s) => f1(s) + case v: JNum => f2(v.asDouble) + case JTrue => f3(true) + case JFalse => f3(false) + case JNull => f4 + } +} + +case object JNull extends JAtom { + final def valueType: String = "null" +} + +sealed abstract class JBool extends JAtom { + final def valueType: String = "boolean" + final override def getBoolean: Option[Boolean] = Some(this == JTrue) + final override def asBoolean: Boolean = this == JTrue +} + +object JBool { + final val True: JBool = JTrue + final val False: JBool = JFalse + + final def apply(b: Boolean): JBool = if (b) JTrue else JFalse +} + +case object JTrue extends JBool +case object JFalse extends JBool + +case class JString(s: String) extends JAtom { + final def valueType: String = "string" + final override def getString: Option[String] = Some(s) + final override def asString: String = s +} + +object JString { + final val empty = JString("") +} + +sealed abstract class JNum extends JAtom { + final def valueType: String = "number" +} + +object JNum { self => + + /** + * Create a JNum from a Long. + * + * This is identical to calling the LongNum(_) constructor. + */ + final def apply(n: Long): JNum = + LongNum(n) + + /** + * Create a JNum from a Double. + * + * This factory constructor performs some error-checking (ensures + * that the given value is a finite Double). If you have already + * done this error-checking, you can use the DoubleNum(_) or + * DeferNum(_) constructors directly. + */ + final def apply(n: Double): JNum = + if (isNaN(n) || isInfinite(n)) throw new InvalidNumException(n.toString) + else DoubleNum(n) + + /** + * Create a JNum from a String. + * + * This factory constructor validates the string (essentially, + * parsing it as a JSON value). If you are already sure this string + * is a valid JSON number, you can use the DeferLong(_) or + * DeferNum(_) constructors directly. + */ + final def apply(s: String): JNum = + JParser.parseUnsafe(s) match { + case jnum: JNum => jnum + case _ => throw new InvalidNumException(s) + } + + final def hybridEq(x: Long, y: Double): Boolean = { + val z = x.toDouble + y == z && z.toLong == x + } + + final val zero: JNum = LongNum(0) + final val one: JNum = LongNum(1) +} + +case class LongNum(n: Long) extends JNum { + + final override def getInt: Option[Int] = Some(n.toInt) + final override def getLong: Option[Long] = Some(n) + final override def getDouble: Option[Double] = Some(n.toDouble) + final override def getBigInt: Option[BigInt] = Some(BigInt(n)) + final override def getBigDecimal: Option[BigDecimal] = Some(BigDecimal(n)) + + final override def asInt: Int = n.toInt + final override def asLong: Long = n + final override def asDouble: Double = n.toDouble + final override def asBigInt: BigInt = BigInt(n) + final override def asBigDecimal: BigDecimal = BigDecimal(n) + + final override def hashCode: Int = n.## + + final override def equals(that: Any): Boolean = + that match { + case LongNum(n2) => n == n2 + case DoubleNum(n2) => JNum.hybridEq(n, n2) + case jn: JNum => jn == this + case _ => false + } +} + +case class DoubleNum(n: Double) extends JNum { + + final override def getInt: Option[Int] = Some(n.toInt) + final override def getLong: Option[Long] = Some(n.toLong) + final override def getDouble: Option[Double] = Some(n) + final override def getBigInt: Option[BigInt] = Some(BigDecimal(n).toBigInt) + final override def getBigDecimal: Option[BigDecimal] = Some(BigDecimal(n)) + + final override def asInt: Int = n.toInt + final override def asLong: Long = n.toLong + final override def asDouble: Double = n + final override def asBigInt: BigInt = BigDecimal(n).toBigInt + final override def asBigDecimal: BigDecimal = BigDecimal(n) + + final override def hashCode: Int = n.## + + final override def equals(that: Any): Boolean = + that match { + case LongNum(n2) => JNum.hybridEq(n2, n) + case DoubleNum(n2) => n == n2 + case jn: JNum => jn == this + case _ => false + } +} + +case class DeferLong(s: String) extends JNum { + + lazy val n: Long = util.parseLongUnsafe(s) + + final override def getInt: Option[Int] = Some(n.toInt) + final override def getLong: Option[Long] = Some(n) + final override def getDouble: Option[Double] = Some(n.toDouble) + final override def getBigInt: Option[BigInt] = Some(BigInt(s)) + final override def getBigDecimal: Option[BigDecimal] = Some(BigDecimal(s)) + + final override def asInt: Int = n.toInt + final override def asLong: Long = n + final override def asDouble: Double = n.toDouble + final override def asBigInt: BigInt = BigInt(s) + final override def asBigDecimal: BigDecimal = BigDecimal(s) + + final override def hashCode: Int = n.## + + final override def equals(that: Any): Boolean = + that match { + case LongNum(n2) => n == n2 + case DoubleNum(n2) => JNum.hybridEq(n, n2) + case jn: DeferLong => n == jn.asLong + case jn: DeferNum => JNum.hybridEq(n, jn.asDouble) + case _ => false + } +} + +case class DeferNum(s: String) extends JNum { + + lazy val n: Double = java.lang.Double.parseDouble(s) + + final override def getInt: Option[Int] = Some(n.toInt) + final override def getLong: Option[Long] = Some(util.parseLongUnsafe(s)) + final override def getDouble: Option[Double] = Some(n) + final override def getBigInt: Option[BigInt] = Some(BigDecimal(s).toBigInt) + final override def getBigDecimal: Option[BigDecimal] = Some(BigDecimal(s)) + + final override def asInt: Int = n.toInt + final override def asLong: Long = util.parseLongUnsafe(s) + final override def asDouble: Double = n + final override def asBigInt: BigInt = BigDecimal(s).toBigInt + final override def asBigDecimal: BigDecimal = BigDecimal(s) + + final override def hashCode: Int = n.## + + final override def equals(that: Any): Boolean = + that match { + case LongNum(n2) => JNum.hybridEq(n2, n) + case DoubleNum(n2) => n == n2 + case jn: DeferLong => JNum.hybridEq(jn.asLong, n) + case jn: DeferNum => n == jn.asDouble + case _ => false + } +} + +case class JArray(vs: Array[JValue]) extends JValue { + final def valueType: String = "array" + + final override def get(i: Int): JValue = + if (0 <= i && i < vs.length) vs(i) else JNull + + final override def set(i: Int, v: JValue): Unit = + vs(i) = v + + final override def hashCode: Int = MurmurHash3.arrayHash(vs) + + final override def equals(that: Any): Boolean = + that match { + case JArray(vs2) => + if (vs.length != vs2.length) return false + var i = 0 + while (i < vs.length) { + if (vs(i) != vs2(i)) return false + i += 1 + } + true + case _ => + false + } +} + +object JArray { self => + final def empty: JArray = + JArray(new Array[JValue](0)) + + final def fromSeq(js: Seq[JValue]): JArray = + JArray(js.toArray) +} + +case class JObject(vs: mutable.Map[String, JValue]) extends JValue { + final def valueType: String = "object" + + final override def get(k: String): JValue = + vs.getOrElse(k, JNull) + + final override def set(k: String, v: JValue): Unit = + vs.put(k, v) + + final override def remove(k: String): Option[JValue] = + vs.remove(k) +} + +object JObject { self => + final def empty: JObject = + JObject(mutable.Map.empty) + + final def fromSeq(js: Seq[(String, JValue)]): JObject = + JObject(mutable.Map(js: _*)) +} diff --git a/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JawnFacade.scala b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JawnFacade.scala new file mode 100644 index 00000000..a2d2d711 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/JawnFacade.scala @@ -0,0 +1,51 @@ +package jawn +package ast + +import scala.collection.mutable + +object JawnFacade extends Facade[JValue] { + + final val jnull = JNull + final val jfalse = JFalse + final val jtrue = JTrue + + final def jnum(s: CharSequence, decIndex: Int, expIndex: Int): JValue = + if (decIndex == -1 && expIndex == -1) { + DeferLong(s.toString) + } else { + DeferNum(s.toString) + } + + final def jstring(s: CharSequence): JValue = + JString(s.toString) + + final def singleContext(): FContext[JValue] = + new FContext[JValue] { + var value: JValue = _ + def add(s: CharSequence) { value = JString(s.toString) } + def add(v: JValue) { value = v } + def finish: JValue = value + def isObj: Boolean = false + } + + final def arrayContext(): FContext[JValue] = + new FContext[JValue] { + val vs = mutable.ArrayBuffer.empty[JValue] + def add(s: CharSequence) { vs.append(JString(s.toString)) } + def add(v: JValue) { vs.append(v) } + def finish: JValue = JArray(vs.toArray) + def isObj: Boolean = false + } + + final def objectContext(): FContext[JValue] = + new FContext[JValue] { + var key: String = null + val vs = mutable.Map.empty[String, JValue] + def add(s: CharSequence): Unit = + if (key == null) { key = s.toString } else { vs(key.toString) = JString(s.toString); key = null } + def add(v: JValue): Unit = + { vs(key) = v; key = null } + def finish = JObject(vs) + def isObj = true + } +} diff --git a/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/Renderer.scala b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/Renderer.scala new file mode 100644 index 00000000..3b2d9103 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/ast/src/main/scala/jawn/ast/Renderer.scala @@ -0,0 +1,101 @@ +package jawn +package ast + +import scala.annotation.switch +import scala.collection.mutable +import scala.util.Sorting + +sealed trait Renderer { + final def render(jv: JValue): String = { + val sb = new StringBuilder + render(sb, 0, jv) + sb.toString + } + + final def render(sb: StringBuilder, depth: Int, jv: JValue): Unit = + jv match { + case JNull => sb.append("null") + case JTrue => sb.append("true") + case JFalse => sb.append("false") + case LongNum(n) => sb.append(n.toString) + case DoubleNum(n) => sb.append(n.toString) + case DeferNum(s) => sb.append(s) + case DeferLong(s) => sb.append(s) + case JString(s) => renderString(sb, s) + case JArray(vs) => renderArray(sb, depth, vs) + case JObject(vs) => renderObject(sb, depth, canonicalizeObject(vs)) + } + + def canonicalizeObject(vs: mutable.Map[String, JValue]): Iterator[(String, JValue)] + + def renderString(sb: StringBuilder, s: String): Unit + + final def renderArray(sb: StringBuilder, depth: Int, vs: Array[JValue]): Unit = { + if (vs.isEmpty) return { sb.append("[]"); () } + sb.append("[") + render(sb, depth + 1, vs(0)) + var i = 1 + while (i < vs.length) { + sb.append(",") + render(sb, depth + 1, vs(i)) + i += 1 + } + sb.append("]") + } + + final def renderObject(sb: StringBuilder, depth: Int, it: Iterator[(String, JValue)]): Unit = { + if (!it.hasNext) return { sb.append("{}"); () } + val (k0, v0) = it.next + sb.append("{") + renderString(sb, k0) + sb.append(":") + render(sb, depth + 1, v0) + while (it.hasNext) { + val (k, v) = it.next + sb.append(",") + renderString(sb, k) + sb.append(":") + render(sb, depth + 1, v) + } + sb.append("}") + } + + final def escape(sb: StringBuilder, s: String, unicode: Boolean): Unit = { + sb.append('"') + var i = 0 + val len = s.length + while (i < len) { + (s.charAt(i): @switch) match { + case '"' => sb.append("\\\"") + case '\\' => sb.append("\\\\") + case '\b' => sb.append("\\b") + case '\f' => sb.append("\\f") + case '\n' => sb.append("\\n") + case '\r' => sb.append("\\r") + case '\t' => sb.append("\\t") + case c => + if (c < ' ' || (c > '~' && unicode)) sb.append("\\u%04x" format c.toInt) + else sb.append(c) + } + i += 1 + } + sb.append('"') + } +} + +object CanonicalRenderer extends Renderer { + def canonicalizeObject(vs: mutable.Map[String, JValue]): Iterator[(String, JValue)] = { + val keys = vs.keys.toArray + Sorting.quickSort(keys) + keys.iterator.map(k => (k, vs(k))) + } + def renderString(sb: StringBuilder, s: String): Unit = + escape(sb, s, true) +} + +object FastRenderer extends Renderer { + def canonicalizeObject(vs: mutable.Map[String, JValue]): Iterator[(String, JValue)] = + vs.iterator + def renderString(sb: StringBuilder, s: String): Unit = + escape(sb, s, false) +} diff --git a/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ArbitraryUtil.scala b/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ArbitraryUtil.scala new file mode 100644 index 00000000..6fdb8fbe --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ArbitraryUtil.scala @@ -0,0 +1,49 @@ +package jawn +package ast + +import org.scalacheck._ +import Gen._ +import Arbitrary.arbitrary + +object ArbitraryUtil { + + // JSON doesn't allow NaN, PositiveInfinity, or NegativeInfinity + def isFinite(n: Double): Boolean = + !java.lang.Double.isNaN(n) && !java.lang.Double.isInfinite(n) + + val jnull = Gen.const(JNull) + val jboolean = Gen.oneOf(JTrue :: JFalse :: Nil) + val jlong = arbitrary[Long].map(LongNum(_)) + val jdouble = arbitrary[Double].filter(isFinite).map(DoubleNum(_)) + val jstring = arbitrary[String].map(JString(_)) + + // Totally unscientific atom frequencies. + val jatom: Gen[JAtom] = + Gen.frequency( + (1, jnull), + (8, jboolean), + (8, jlong), + (8, jdouble), + (16, jstring)) + + // Use lvl to limit the depth of our jvalues. + // Otherwise we will end up with SOE real fast. + + val MaxLevel: Int = 3 + + def jarray(lvl: Int): Gen[JArray] = + Gen.containerOf[Array, JValue](jvalue(lvl + 1)).map(JArray(_)) + + def jitem(lvl: Int): Gen[(String, JValue)] = + for { s <- arbitrary[String]; j <- jvalue(lvl) } yield (s, j) + + def jobject(lvl: Int): Gen[JObject] = + Gen.containerOf[Vector, (String, JValue)](jitem(lvl + 1)).map(JObject.fromSeq) + + def jvalue(lvl: Int = 0): Gen[JValue] = + if (lvl >= MaxLevel) jatom + else Gen.frequency((16, jatom), (1, jarray(lvl)), (2, jobject(lvl))) + + implicit lazy val arbitraryJValue: Arbitrary[JValue] = + Arbitrary(jvalue()) +} diff --git a/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/AstTest.scala b/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/AstTest.scala new file mode 100644 index 00000000..3ec7373e --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/AstTest.scala @@ -0,0 +1,79 @@ +package jawn +package ast + +import org.scalatest._ +import org.scalatest.prop._ + +import scala.collection.mutable +import scala.util.{Try, Success} + +import ArbitraryUtil._ + +class AstTest extends PropSpec with Matchers with PropertyChecks { + + property("calling .get never crashes") { + forAll { (v: JValue, s: String, i: Int) => + Try(v.get(i).get(s)).isSuccess shouldBe true + Try(v.get(s).get(i)).isSuccess shouldBe true + Try(v.get(i).get(i)).isSuccess shouldBe true + Try(v.get(s).get(s)).isSuccess shouldBe true + } + } + + property(".getX and .asX agree") { + forAll { (v: JValue) => + v.getBoolean shouldBe Try(v.asBoolean).toOption + v.getString shouldBe Try(v.asString).toOption + v.getInt shouldBe Try(v.asInt).toOption + v.getLong shouldBe Try(v.asLong).toOption + v.getDouble shouldBe Try(v.asDouble).toOption + v.getBigInt shouldBe Try(v.asBigInt).toOption + v.getBigDecimal shouldBe Try(v.asBigDecimal).toOption + } + } + + property(".getBoolean") { + forAll((b: Boolean) => JBool(b).getBoolean shouldBe Some(b)) + } + + property(".getString") { + forAll((s: String) => JString(s).getString shouldBe Some(s)) + } + + property(".getInt") { + forAll { (n: Int) => + JNum(n).getInt shouldBe Some(n) + JParser.parseUnsafe(n.toString).getInt shouldBe Some(n) + } + } + + property(".getLong") { + forAll { (n: Long) => + JNum(n).getLong shouldBe Some(n) + JParser.parseUnsafe(n.toString).getLong shouldBe Some(n) + } + } + + property(".getDouble") { + forAll { (n: Double) => + JNum(n).getDouble shouldBe Some(n) + JParser.parseUnsafe(n.toString).getDouble shouldBe Some(n) + } + } + + property(".getBigInt") { + forAll { (n: BigInt) => + JNum(n.toString).getBigInt shouldBe Some(n) + JParser.parseUnsafe(n.toString).getBigInt shouldBe Some(n) + } + } + + property(".getBigDecimal") { + forAll { (n: BigDecimal) => + if (Try(BigDecimal(n.toString)) == Success(n)) { + JNum(n.toString).getBigDecimal shouldBe Some(n) + JParser.parseUnsafe(n.toString).getBigDecimal shouldBe Some(n) + } + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ParseCheck.scala b/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ParseCheck.scala new file mode 100644 index 00000000..a5a5aa18 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/ast/src/test/scala/jawn/ParseCheck.scala @@ -0,0 +1,169 @@ +package jawn +package ast + +import org.scalatest._ +import org.scalatest.prop._ +import org.scalacheck.Arbitrary._ +import org.scalacheck._ +import Gen._ +import Arbitrary.arbitrary + +import scala.collection.mutable +import scala.util.{Try, Success} + +import jawn.parser.TestUtil + +import ArbitraryUtil._ + +class AstCheck extends PropSpec with Matchers with PropertyChecks { + + // so it's only one property, but it exercises: + // + // * parsing from strings + // * rendering jvalues to string + // * jvalue equality + // + // not bad. + property("idempotent parsing/rendering") { + forAll { value1: JValue => + val json1 = CanonicalRenderer.render(value1) + val value2 = JParser.parseFromString(json1).get + val json2 = CanonicalRenderer.render(value2) + json2 shouldBe json1 + json2.## shouldBe json1.## + + value1 shouldBe value2 + value1.## shouldBe value2.## + + TestUtil.withTemp(json1) { t => + JParser.parseFromFile(t).get shouldBe value2 + } + } + } + + property("string encoding/decoding") { + forAll { s: String => + val jstr1 = JString(s) + val json1 = CanonicalRenderer.render(jstr1) + val jstr2 = JParser.parseFromString(json1).get + val json2 = CanonicalRenderer.render(jstr2) + jstr2 shouldBe jstr1 + json2 shouldBe json1 + json2.## shouldBe json1.## + } + } + + property("string/charSequence parsing") { + forAll { value: JValue => + val s = CanonicalRenderer.render(value) + val j1 = JParser.parseFromString(s) + val cs = java.nio.CharBuffer.wrap(s.toCharArray) + val j2 = JParser.parseFromCharSequence(cs) + j1 shouldBe j2 + j1.## shouldBe j2.## + } + } + + implicit val facade = JawnFacade + + val percs = List(0.0, 0.2, 0.4, 0.8, 1.0) + + def checkRight(r: Either[ParseException, Seq[JValue]]): Seq[JValue] = { + r.isRight shouldBe true + val Right(vs) = r + vs + } + + def splitIntoSegments(json: String): List[String] = + if (json.length >= 8) { + val offsets = percs.map(n => (json.length * n).toInt) + val pairs = offsets zip offsets.drop(1) + pairs.map { case (i, j) => json.substring(i, j) } + } else { + json :: Nil + } + + def parseSegments(p: AsyncParser[JValue], segments: List[String]): Seq[JValue] = + segments.foldLeft(List.empty[JValue]) { (rs, s) => + rs ++ checkRight(p.absorb(s)) + } ++ checkRight(p.finish()) + + import AsyncParser.{UnwrapArray, ValueStream, SingleValue} + + property("async multi") { + val data = "[1,2,3][4,5,6]" + val p = AsyncParser[JValue](ValueStream) + val res0 = p.absorb(data) + val res1 = p.finish + //println((res0, res1)) + true + } + + property("async parsing") { + forAll { (v: JValue) => + val json = CanonicalRenderer.render(v) + val segments = splitIntoSegments(json) + val parsed = parseSegments(AsyncParser[JValue](SingleValue), segments) + parsed shouldBe List(v) + } + } + + property("async unwrapping") { + forAll { (vs0: List[Int]) => + val vs = vs0.map(LongNum(_)) + val arr = JArray(vs.toArray) + val json = CanonicalRenderer.render(arr) + val segments = splitIntoSegments(json) + parseSegments(AsyncParser[JValue](UnwrapArray), segments) shouldBe vs + } + } + + property("unicode string round-trip") { + forAll { (s: String) => + JParser.parseFromString(JString(s).render(FastRenderer)) shouldBe Success(JString(s)) + } + } + + property("if x == y, then x.## == y.##") { + forAll { (x: JValue, y: JValue) => + if (x == y) x.## shouldBe y.## + } + } + + property("ignore trailing zeros") { + forAll { (n: Int) => + val s = n.toString + val n1 = LongNum(n) + val n2 = DoubleNum(n) + + def check(j: JValue) { + j shouldBe n1; n1 shouldBe j + j shouldBe n2; n2 shouldBe j + } + + check(DeferNum(s)) + check(DeferNum(s + ".0")) + check(DeferNum(s + ".00")) + check(DeferNum(s + ".000")) + check(DeferNum(s + "e0")) + check(DeferNum(s + ".0e0")) + } + } + + property("large strings") { + val M = 1000000 + val q = "\"" + + val s0 = ("x" * (40 * M)) + val e0 = q + s0 + q + TestUtil.withTemp(e0) { t => + JParser.parseFromFile(t).filter(_ == JString(s0)).isSuccess shouldBe true + } + + val s1 = "\\" * (20 * M) + val e1 = q + s1 + s1 + q + TestUtil.withTemp(e1) { t => + JParser.parseFromFile(t).filter(_ == JString(s1)).isSuccess shouldBe true + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/benchmark/build.sbt b/scalaplugin/src/test/resource/jawn/benchmark/build.sbt new file mode 100644 index 00000000..7cb15b12 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/benchmark/build.sbt @@ -0,0 +1,21 @@ +name := "jawn-benchmarks" + +javaOptions in run += "-Xmx6G" + +libraryDependencies ++= Seq( + "io.argonaut" %% "argonaut" % "6.2", + "org.json4s" %% "json4s-native" % "3.5.2", + "org.json4s" %% "json4s-jackson" % "3.5.2", + "com.typesafe.play" %% "play-json" % "2.5.15", + "com.rojoma" %% "rojoma-json" % "2.4.3", + "com.rojoma" %% "rojoma-json-v3" % "3.7.2", + "io.spray" %% "spray-json" % "1.3.3", + "org.parboiled" %% "parboiled" % "2.1.4", + "com.fasterxml.jackson.core" % "jackson-annotations" % "2.8.4", + "com.fasterxml.jackson.core" % "jackson-core" % "2.8.4", + "com.fasterxml.jackson.core" % "jackson-databind" % "2.8.4", + "com.google.code.gson" % "gson" % "2.8.1" +) + +// enable forking in run +fork in run := true diff --git a/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/JmhBenchmarks.scala b/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/JmhBenchmarks.scala new file mode 100644 index 00000000..bc56f9f6 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/JmhBenchmarks.scala @@ -0,0 +1,120 @@ +package jawn +package benchmark + +import java.io.{BufferedReader, File, FileInputStream, FileReader} +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.annotations._ +import scala.collection.mutable + +@State(Scope.Benchmark) +@BenchmarkMode(Array(Mode.AverageTime)) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +abstract class JmhBenchmarks(name: String) { + val path: String = s"src/main/resources/$name" + + def load(path: String): String = { + val file = new File(path) + val bytes = new Array[Byte](file.length.toInt) + val fis = new FileInputStream(file) + fis.read(bytes) + new String(bytes, "UTF-8") + } + + def reader(path: String): FileReader = + new FileReader(new File(path)) + + def buffered(path: String): BufferedReader = + new BufferedReader(new FileReader(new File(path))) + + @Benchmark + def jawnCheckSyntax() = + jawn.Syntax.checkString(load(path)) + + @Benchmark + def jawnParse() = + jawn.ast.JParser.parseFromFile(new File(path)).get + + @Benchmark + def jawnStringParse() = + jawn.ast.JParser.parseFromString(load(path)).get +} + +trait OtherBenchmarks { self: JmhBenchmarks => + @Benchmark + def json4sJacksonParse() = { + import org.json4s._ + import org.json4s.jackson.JsonMethods._ + parse(load(path)) + } + + @Benchmark + def playParse() = + play.api.libs.json.Json.parse(load(path)) + + @Benchmark + def rojomaV3Parse() = + com.rojoma.json.v3.io.JsonReader.fromReader(reader(path), blockSize = 100000) + + @Benchmark + def argonautParse() = + argonaut.Parse.parse(load(path)) + + @Benchmark + def sprayParse() = + spray.json.JsonParser(load(path)) + + @Benchmark + def parboiledJsonParse() = + new ParboiledParser(load(path)).Json.run().get + + @Benchmark + def jacksonParse() = { + import com.fasterxml.jackson.databind.ObjectMapper + import com.fasterxml.jackson.databind.JsonNode + new ObjectMapper().readValue(new File(path), classOf[JsonNode]) + } + + @Benchmark + def gsonParse() = + new com.google.gson.JsonParser().parse(buffered(path)) + + // don't bother benchmarking jawn + external asts by default + + // @Benchmark + // def json4sJawnParse() = + // jawn.support.json4s.Parser.parseFromFile(new File(path)).get + // + // @Benchmark + // def rojomaV3JawnParse() = + // jawn.support.rojoma.v3.Parser.parseFromFile(new File(path)).get + // + // @Benchmark + // def argonautJawnParse() = + // jawn.support.argonaut.Parser.parseFromFile(new File(path)).get + // + // @Benchmark + // def sprayJawnParse() = + // jawn.support.spray.Parser.parseFromFile(new File(path)).get + + // native json4s parser is really, really slow, so it's disabled by default. + + // @Benchmark + // def json4sNativeParse() = { + // import org.json4s._ + // import org.json4s.native.JsonMethods._ + // parse(load(path)) + // } +} + +class Qux2Bench extends JmhBenchmarks("qux2.json") with OtherBenchmarks +class Bla25Bench extends JmhBenchmarks("bla25.json") with OtherBenchmarks +class CountriesBench extends JmhBenchmarks("countries.geo.json") with OtherBenchmarks +class Ugh10kBench extends JmhBenchmarks("ugh10k.json") with OtherBenchmarks + +class JawnOnlyQux2Bench extends JmhBenchmarks("qux2.json") +class JawnOnlyBla25Bench extends JmhBenchmarks("bla25.json") +class JawnOnlyCountriesBench extends JmhBenchmarks("countries.geo.json") +class JawnOnlyUgh10kBench extends JmhBenchmarks("ugh10k.json") + +// // from https://github.com/zemirco/sf-city-lots-json +// class CityLotsBench extends JmhBenchmarks("citylots.json") diff --git a/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/Parboiled.scala b/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/Parboiled.scala new file mode 100644 index 00000000..bd5fed18 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/Parboiled.scala @@ -0,0 +1,105 @@ +package jawn.benchmark + +/* + * Copyright (C) 2009-2013 Mathias Doenitz, Alexander Myltsev + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import scala.annotation.switch +import org.parboiled2._ +import spray.json.{ParserInput => _, _} + +/** + * This is a feature-complete JSON parser implementation that almost directly + * models the JSON grammar presented at http://www.json.org as a parboiled2 PEG parser. + */ +class ParboiledParser(val input: ParserInput) extends Parser with StringBuilding { + import CharPredicate.{Digit, Digit19, HexDigit} + import ParboiledParser._ + + // the root rule + def Json = rule { WhiteSpace ~ Value ~ EOI } + + def JsonObject: Rule1[JsObject] = rule { + ws('{') ~ zeroOrMore(Pair).separatedBy(ws(',')) ~ ws('}') ~> ((fields: Seq[JsField]) => JsObject(fields :_*)) + } + + def Pair = rule { JsonStringUnwrapped ~ ws(':') ~ Value ~> ((_, _)) } + + def Value: Rule1[JsValue] = rule { + // as an optimization of the equivalent rule: + // JsonString | JsonNumber | JsonObject | JsonArray | JsonTrue | JsonFalse | JsonNull + // we make use of the fact that one-char lookahead is enough to discriminate the cases + run { + (cursorChar: @switch) match { + case '"' => JsonString + case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '-' => JsonNumber + case '{' => JsonObject + case '[' => JsonArray + case 't' => JsonTrue + case 'f' => JsonFalse + case 'n' => JsonNull + case _ => MISMATCH + } + } + } + + def JsonString = rule { JsonStringUnwrapped ~> (JsString(_)) } + + def JsonStringUnwrapped = rule { '"' ~ clearSB() ~ Characters ~ ws('"') ~ push(sb.toString) } + + def JsonNumber = rule { capture(Integer ~ optional(Frac) ~ optional(Exp)) ~> (JsNumber(_)) ~ WhiteSpace } + + def JsonArray = rule { ws('[') ~ zeroOrMore(Value).separatedBy(ws(',')) ~ ws(']') ~> (JsArray(_ :_*)) } + + def Characters = rule { zeroOrMore(NormalChar | '\\' ~ EscapedChar) } + + def NormalChar = rule { !QuoteBackslash ~ ANY ~ appendSB() } + + def EscapedChar = rule ( + QuoteSlashBackSlash ~ appendSB() + | 'b' ~ appendSB('\b') + | 'f' ~ appendSB('\f') + | 'n' ~ appendSB('\n') + | 'r' ~ appendSB('\r') + | 't' ~ appendSB('\t') + | Unicode ~> { code => sb.append(code.asInstanceOf[Char]); () } + ) + + def Unicode = rule { 'u' ~ capture(HexDigit ~ HexDigit ~ HexDigit ~ HexDigit) ~> (java.lang.Integer.parseInt(_, 16)) } + + def Integer = rule { optional('-') ~ (Digit19 ~ Digits | Digit) } + + def Digits = rule { oneOrMore(Digit) } + + def Frac = rule { "." ~ Digits } + + def Exp = rule { ignoreCase('e') ~ optional(anyOf("+-")) ~ Digits } + + def JsonTrue = rule { "true" ~ WhiteSpace ~ push(JsTrue) } + + def JsonFalse = rule { "false" ~ WhiteSpace ~ push(JsFalse) } + + def JsonNull = rule { "null" ~ WhiteSpace ~ push(JsNull) } + + def WhiteSpace = rule { zeroOrMore(WhiteSpaceChar) } + + def ws(c: Char) = rule { c ~ WhiteSpace } +} + +object ParboiledParser { + val WhiteSpaceChar = CharPredicate(" \n\r\t\f") + val QuoteBackslash = CharPredicate("\"\\") + val QuoteSlashBackSlash = QuoteBackslash ++ "/" +} diff --git a/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/ParseLongBench.scala b/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/ParseLongBench.scala new file mode 100644 index 00000000..97e8e6a8 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/benchmark/src/main/scala/jawn/ParseLongBench.scala @@ -0,0 +1,133 @@ +package jawn +package benchmark + +import java.io.{BufferedReader, File, FileInputStream, FileReader} +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.annotations._ +import scala.collection.mutable + +case class Slice(s: String, begin: Int, limit: Int) extends CharSequence { + val length: Int = limit - begin + def charAt(i: Int): Char = s.charAt(begin + i) + def subSequence(start: Int, end: Int): Slice = + Slice(s, begin + start, Math.min(end + begin, limit)) + override def toString: String = + s.substring(begin, limit) +} + +@State(Scope.Benchmark) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +class ParseLongBench { + + val longs: Array[Long] = Array( + -1346837161442476189L, -4666345991836441070L, 4868830844043235709L, + 2992690405064579158L, -2017521011608078634L, -3039682866169364757L, + 8997687047891586260L, 5932727796276454607L, 4062739618560250554L, + 8668950167358198490L, -8565613821858118870L, 8049785848575684314L, + -580831266940599830L, -3593199367295538945L, 8374322595267797482L, + 3088261552516619129L, -6879203747403593851L, -1842900848925949857L, + 4484592876047641351L, 5182973278356955602L, -6840392853855436945L, + -4176340556015032222L, -536379174926548619L, 6343722878919863216L, + 1557757008211571405L, -334093799456298669L, 619602023052756397L, + 6904874397154297343L, -4332034907782234995L, -8767842695446545180L, + -6127250063205613011L, 6902212562850963795L, 4778607575334665692L, + 7674074815344809639L, -3834944692798167050L, 7406081418831471202L, + -9126886315356724563L, 8093878176633322645L, 2471547025788214028L, + -5018828829942988155L, -6676531171364391367L, 8189793226936659851L, + 7150026713387306746L, -6065566098373722052L, 3281133763697608570L, + 957103694526079944L, -3009447279791131829L, -1995600795755716697L, + 2361055030313262510L, -4312828282749171343L, 8836216125516165138L, + 5548785979447786253L, 8567551485822958810L, 5931896003625723150L, + 3472058092439106147L, 4363240277904515929L, -2999484068697753019L, + -8285358702782547958L, -2407429647076308777L, 4411565001760018584L, + 792384115860070648L, 3328145302561962294L, -2377559446421434356L, + -7837698939558960516L, -565806101451282875L, -4792610084643070650L, + 2713520205731589923L, -6521104721472605988L, 5037187811345411645L, + 3866939564433764178L, -3851229228204678079L, -8171137274242372558L, + -14713951794749384L, 2061783257002637655L, -7375571393873059570L, + 7402007407273053723L, -5104318069025846447L, -8956415532448219980L, + 4904595193891993401L, 5396360181536889307L, -8043917553767343384L, + -3666269817017255250L, -6535587792359353103L, -4553034734642385706L, + -7544140164897268962L, 2468330113904053484L, 5790319365381968237L, + -2734383156062609640L, -4831208471935595172L, 4502079643250626043L, + 4778622151522470246L, 7233054223498326990L, 5833883346008509644L, + -8013495378054295093L, 2944606201054530456L, -8608231828651976245L, + -6957117814546267426L, -4744827311133020624L, 2640030216500286789L, + 8343959867315747844L) + + val strs: Array[CharSequence] = + longs.map(_.toString) + + val seqs: Array[CharSequence] = + longs.map { n => + val prefix = "x" * (n & 63).toInt + val suffix = "y" * ((n * 7) & 63).toInt + val i = prefix.length + val s = n.toString + Slice(prefix + s + suffix, i, s.length + i) + } + + val str: CharSequence = "23948271429443" + + val seq: CharSequence = Slice("weigjewigjwi23948271429443jgewigjweiwjegiwgjiewjgeiwjg", 12, 26) + + def sumJava(css: Array[CharSequence]): Long = { + var sum: Long = 0 + var i = 0 + while (i < css.length) { + sum += java.lang.Long.parseLong(css(i).toString) + i += 1 + } + sum + } + + def sumStd(css: Array[CharSequence]): Long = { + var sum: Long = 0 + var i = 0 + while (i < css.length) { + sum += css(i).toString.toLong + i += 1 + } + sum + } + + def sumSafe(css: Array[CharSequence]): Long = { + var sum: Long = 0 + var i = 0 + while (i < css.length) { + sum += Util.parseLong(css(i)) + i += 1 + } + sum + } + + def sumUnsafe(css: Array[CharSequence]): Long = { + var sum: Long = 0 + var i = 0 + while (i < css.length) { + sum += Util.parseLongUnsafe(css(i)) + i += 1 + } + sum + } + + @Benchmark def stringArrayJava(): Long = sumJava(strs) + @Benchmark def seqArrayJava(): Long = sumJava(seqs) + @Benchmark def stringValueJava(): Long = java.lang.Long.parseLong(str.toString) + @Benchmark def seqValueJava(): Long = java.lang.Long.parseLong(seq.toString) + + @Benchmark def stringArrayStd(): Long = sumStd(strs) + @Benchmark def seqArrayStd(): Long = sumStd(seqs) + @Benchmark def stringValueStd(): Long = str.toString.toLong + @Benchmark def seqValueStd(): Long = seq.toString.toLong + + @Benchmark def stringArraySafe(): Long = sumSafe(strs) + @Benchmark def seqArraySafe(): Long = sumSafe(seqs) + @Benchmark def stringValueSafe(): Long = Util.parseLong(str) + @Benchmark def seqValueSafe(): Long = Util.parseLong(seq) + + @Benchmark def stringArrayUnsafe(): Long = sumUnsafe(strs) + @Benchmark def seqArrayUnsafe(): Long = sumUnsafe(seqs) + @Benchmark def stringValueUnsafe(): Long = Util.parseLongUnsafe(str) + @Benchmark def seqValueUnsafe(): Long = Util.parseLongUnsafe(seq) +} diff --git a/scalaplugin/src/test/resource/jawn/build.sbt b/scalaplugin/src/test/resource/jawn/build.sbt new file mode 100644 index 00000000..c32403ed --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/build.sbt @@ -0,0 +1,162 @@ +import ReleaseTransformations._ + +lazy val previousJawnVersion = "0.10.4" + +lazy val stableCrossVersions = + Seq("2.10.6", "2.11.11", "2.12.2") + +// we'll support 2.13.0-M1 soon but not yet +lazy val allCrossVersions = + stableCrossVersions + +lazy val benchmarkVersion = + "2.12.2" + +lazy val jawnSettings = Seq( + organization := "org.spire-math", + scalaVersion := "2.12.2", + crossScalaVersions := allCrossVersions, + + mimaPreviousArtifacts := Set(organization.value %% moduleName.value % previousJawnVersion), + + resolvers += Resolver.sonatypeRepo("releases"), + + libraryDependencies ++= + "org.scalatest" %% "scalatest" % "3.0.3" % Test :: + "org.scalacheck" %% "scalacheck" % "1.13.5" % Test :: + Nil, + + scalacOptions ++= + "-deprecation" :: + "-optimize" :: + "-unchecked" :: + Nil, + + licenses += ("MIT", url("http://opensource.org/licenses/MIT")), + homepage := Some(url("http://github.com/non/jawn")), + + // release stuff + releaseCrossBuild := true, + publishMavenStyle := true, + publishArtifact in Test := false, + pomIncludeRepository := Function.const(false), + + publishTo := { + val nexus = "https://oss.sonatype.org/" + if (isSnapshot.value) { + Some("Snapshots" at nexus + "content/repositories/snapshots") + } else { + Some("Releases" at nexus + "service/local/staging/deploy/maven2") + } + }, + + scmInfo := Some(ScmInfo( + browseUrl = url("https://github.com/non/jawn"), + connection = "scm:git:git@github.com:non/jawn.git" + )), + + developers += Developer( + name = "Erik Osheim", + email = "erik@plastic-idolatry.com", + id = "d_m", + url = url("http://github.com/non/") + ), + + releaseProcess := Seq[ReleaseStep]( + checkSnapshotDependencies, + inquireVersions, + runClean, + ReleaseHelper.runCommandAndRemaining("+test"), // formerly runTest + setReleaseVersion, + commitReleaseVersion, + tagRelease, + ReleaseHelper.runCommandAndRemaining("+publishSigned"), + setNextVersion, + commitNextVersion, + ReleaseStep(action = Command.process("sonatypeReleaseAll", _)), + pushChanges)) + +lazy val noPublish = Seq( + publish := {}, + publishLocal := {}, + publishArtifact := false, + mimaPreviousArtifacts := Set()) + +lazy val root = project.in(file(".")) + .aggregate(all.map(Project.projectToRef): _*) + .enablePlugins(CrossPerProjectPlugin) + .disablePlugins(JmhPlugin) + .settings(name := "jawn") + .settings(jawnSettings: _*) + .settings(noPublish: _*) + +lazy val parser = project.in(file("parser")) + .settings(name := "parser") + .settings(moduleName := "jawn-parser") + .settings(jawnSettings: _*) + .disablePlugins(JmhPlugin) + +lazy val util = project.in(file("util")) + .dependsOn(parser % "compile->compile;test->test") + .settings(name := "util") + .settings(moduleName := "jawn-util") + .settings(jawnSettings: _*) + .disablePlugins(JmhPlugin) + +lazy val ast = project.in(file("ast")) + .dependsOn(parser % "compile->compile;test->test") + .dependsOn(util % "compile->compile;test->test") + .settings(name := "ast") + .settings(moduleName := "jawn-ast") + .settings(jawnSettings: _*) + .disablePlugins(JmhPlugin) + +def support(s: String) = + Project(id = s, base = file(s"support/$s")) + .settings(name := (s + "-support")) + .settings(moduleName := "jawn-" + s) + .dependsOn(parser) + .settings(jawnSettings: _*) + .disablePlugins(JmhPlugin) + +lazy val supportArgonaut = support("argonaut") + .settings(crossScalaVersions := stableCrossVersions) + .settings(libraryDependencies += "io.argonaut" %% "argonaut" % "6.2") + +lazy val supportJson4s = support("json4s") + .dependsOn(util) + .settings(crossScalaVersions := stableCrossVersions) + .settings(libraryDependencies += "org.json4s" %% "json4s-ast" % "3.5.2") + +lazy val supportPlay = support("play") + .settings(crossScalaVersions := stableCrossVersions) + .settings(libraryDependencies += (scalaBinaryVersion.value match { + case "2.10" => "com.typesafe.play" %% "play-json" % "2.4.11" + case "2.11" => "com.typesafe.play" %% "play-json" % "2.5.15" + case _ => "com.typesafe.play" %% "play-json" % "2.6.0" + })) + +lazy val supportRojoma = support("rojoma") + .settings(crossScalaVersions := stableCrossVersions) + .settings(libraryDependencies += "com.rojoma" %% "rojoma-json" % "2.4.3") + +lazy val supportRojomaV3 = support("rojoma-v3") + .settings(crossScalaVersions := stableCrossVersions) + .settings(libraryDependencies += "com.rojoma" %% "rojoma-json-v3" % "3.7.2") + +lazy val supportSpray = support("spray") + .settings(crossScalaVersions := stableCrossVersions) + .settings(resolvers += "spray" at "http://repo.spray.io/") + .settings(libraryDependencies += "io.spray" %% "spray-json" % "1.3.3") + +lazy val benchmark = project.in(file("benchmark")) + .dependsOn(all.map(Project.classpathDependency[Project]): _*) + .settings(name := "jawn-benchmark") + .settings(jawnSettings: _*) + .settings(scalaVersion := benchmarkVersion) + .settings(crossScalaVersions := Seq(benchmarkVersion)) + .settings(noPublish: _*) + .enablePlugins(JmhPlugin) + +lazy val all = + Seq(parser, util, ast, supportArgonaut, supportJson4s, supportPlay, supportRojoma, supportRojomaV3, supportSpray) diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/resources/utf8.json b/scalaplugin/src/test/resource/jawn/parser/src/main/resources/utf8.json new file mode 100644 index 00000000..6549eaa0 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/resources/utf8.json @@ -0,0 +1,7 @@ +{ + "copyright": "©", + "accent-e": "é", + "combined-e": "é", + "devenagari": "क्तु", + "math": "𝔊" +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/AsyncParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/AsyncParser.scala new file mode 100644 index 00000000..acf770d7 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/AsyncParser.scala @@ -0,0 +1,319 @@ +package jawn + +import scala.annotation.{switch, tailrec} +import scala.math.max +import scala.collection.mutable +import scala.util.control +import java.nio.ByteBuffer + +object AsyncParser { + + sealed abstract class Mode(val start: Int, val value: Int) + case object UnwrapArray extends Mode(-5, 1) + case object ValueStream extends Mode(-1, 0) + case object SingleValue extends Mode(-1, -1) + + def apply[J](mode: Mode = SingleValue): AsyncParser[J] = + new AsyncParser(state = mode.start, curr = 0, stack = Nil, + data = new Array[Byte](131072), len = 0, allocated = 131072, + offset = 0, done = false, streamMode = mode.value) +} + +/** + * AsyncParser is able to parse chunks of data (encoded as + * Option[ByteBuffer] instances) and parse asynchronously. You can + * use the factory methods in the companion object to instantiate an + * async parser. + * + * The async parser's fields are described below: + * + * The (state, curr, stack) triple is used to save and restore parser + * state between async calls. State also helps encode extra + * information when streaming or unwrapping an array. + * + * The (data, len, allocated) triple is used to manage the underlying + * data the parser is keeping track of. As new data comes in, data may + * be expanded if not enough space is available. + * + * The offset parameter is used to drive the outer async parsing. It + * stores similar information to curr but is kept separate to avoid + * "corrupting" our snapshot. + * + * The done parameter is used internally to help figure out when the + * atEof() parser method should return true. This will be set when + * apply(None) is called. + * + * The streamMode parameter controls how the asynchronous parser will + * be handling multiple values. There are three states: + * + * 1: An array is being unwrapped. Normal JSON array rules apply + * (Note that if the outer value observed is not an array, this + * mode will toggle to the -1 mode). + * + * 0: A stream of individual JSON elements separated by whitespace + * are being parsed. We can return each complete element as we + * parse it. + * + * -1: No streaming is occuring. Only a single JSON value is + * allowed. + */ +final class AsyncParser[J] protected[jawn] ( + protected[jawn] var state: Int, + protected[jawn] var curr: Int, + protected[jawn] var stack: List[FContext[J]], + protected[jawn] var data: Array[Byte], + protected[jawn] var len: Int, + protected[jawn] var allocated: Int, + protected[jawn] var offset: Int, + protected[jawn] var done: Boolean, + protected[jawn] var streamMode: Int +) extends ByteBasedParser[J] { + + protected[this] var line = 0 + protected[this] var pos = 0 + protected[this] final def newline(i: Int) { line += 1; pos = i + 1 } + protected[this] final def column(i: Int) = i - pos + + final def copy() = + new AsyncParser(state, curr, stack, data.clone, len, allocated, offset, done, streamMode) + + final def absorb(buf: ByteBuffer)(implicit facade: Facade[J]): Either[ParseException, Seq[J]] = { + done = false + val buflen = buf.limit - buf.position + val need = len + buflen + resizeIfNecessary(need) + buf.get(data, len, buflen) + len = need + churn() + } + + final def absorb(bytes: Array[Byte])(implicit facade: Facade[J]): Either[ParseException, Seq[J]] = + absorb(ByteBuffer.wrap(bytes)) + + final def absorb(s: String)(implicit facade: Facade[J]): Either[ParseException, Seq[J]] = + absorb(ByteBuffer.wrap(s.getBytes(utf8))) + + final def finish()(implicit facade: Facade[J]): Either[ParseException, Seq[J]] = { + done = true + churn() + } + + protected[this] final def resizeIfNecessary(need: Int): Unit = { + // if we don't have enough free space available we'll need to grow our + // data array. we never shrink the data array, assuming users will call + // feed with similarly-sized buffers. + if (need > allocated) { + val doubled = if (allocated < 0x40000000) allocated * 2 else Int.MaxValue + val newsize = max(need, doubled) + val newdata = new Array[Byte](newsize) + System.arraycopy(data, 0, newdata, 0, len) + data = newdata + allocated = newsize + } + } + + /** + * Explanation of the new synthetic states. The parser machinery + * uses positive integers for states while parsing json values. We + * use these negative states to keep track of the async parser's + * status between json values. + * + * ASYNC_PRESTART: We haven't seen any non-whitespace yet. We + * could be parsing an array, or not. We are waiting for valid + * JSON. + * + * ASYNC_START: We've seen an array and have begun unwrapping + * it. We could see a ] if the array is empty, or valid JSON. + * + * ASYNC_END: We've parsed an array and seen the final ]. At this + * point we should only see whitespace or an EOF. + * + * ASYNC_POSTVAL: We just parsed a value from inside the array. We + * expect to see whitespace, a comma, or a ]. + * + * ASYNC_PREVAL: We are in an array and we just saw a comma. We + * expect to see whitespace or a JSON value. + */ + @inline private[this] final def ASYNC_PRESTART = -5 + @inline private[this] final def ASYNC_START = -4 + @inline private[this] final def ASYNC_END = -3 + @inline private[this] final def ASYNC_POSTVAL = -2 + @inline private[this] final def ASYNC_PREVAL = -1 + + protected[jawn] def churn()(implicit facade: Facade[J]): Either[ParseException, Seq[J]] = { + + // accumulates json values + val results = mutable.ArrayBuffer.empty[J] + + // we rely on exceptions to tell us when we run out of data + try { + while (true) { + if (state < 0) { + (at(offset): @switch) match { + case '\n' => + newline(offset) + offset += 1 + + case ' ' | '\t' | '\r' => + offset += 1 + + case '[' => + if (state == ASYNC_PRESTART) { + offset += 1 + state = ASYNC_START + } else if (state == ASYNC_END) { + die(offset, "expected eof") + } else if (state == ASYNC_POSTVAL) { + die(offset, "expected , or ]") + } else { + state = 0 + } + + case ',' => + if (state == ASYNC_POSTVAL) { + offset += 1 + state = ASYNC_PREVAL + } else if (state == ASYNC_END) { + die(offset, "expected eof") + } else { + die(offset, "expected json value") + } + + case ']' => + if (state == ASYNC_POSTVAL || state == ASYNC_START) { + if (streamMode > 0) { + offset += 1 + state = ASYNC_END + } else { + die(offset, "expected json value or eof") + } + } else if (state == ASYNC_END) { + die(offset, "expected eof") + } else { + die(offset, "expected json value") + } + + case c => + if (state == ASYNC_END) { + die(offset, "expected eof") + } else if (state == ASYNC_POSTVAL) { + die(offset, "expected ] or ,") + } else { + if (state == ASYNC_PRESTART && streamMode > 0) streamMode = -1 + state = 0 + } + } + + } else { + // jump straight back into rparse + offset = reset(offset) + val (value, j) = if (state <= 0) { + parse(offset) + } else { + rparse(state, curr, stack) + } + if (streamMode > 0) { + state = ASYNC_POSTVAL + } else if (streamMode == 0) { + state = ASYNC_PREVAL + } else { + state = ASYNC_END + } + curr = j + offset = j + stack = Nil + results.append(value) + } + } + Right(results) + } catch { + case e: AsyncException => + if (done) { + // if we are done, make sure we ended at a good stopping point + if (state == ASYNC_PREVAL || state == ASYNC_END) Right(results) + else Left(ParseException("exhausted input", -1, -1, -1)) + } else { + // we ran out of data, so return what we have so far + Right(results) + } + + case e: ParseException => + // we hit a parser error, so return that error and results so far + Left(e) + } + } + + // every 1M we shift our array back by 1M. + protected[this] final def reset(i: Int): Int = { + if (offset >= 1048576) { + len -= 1048576 + offset -= 1048576 + pos -= 1048576 + System.arraycopy(data, 1048576, data, 0, len) + i - 1048576 + } else { + i + } + } + + /** + * We use this to keep track of the last recoverable place we've + * seen. If we hit an AsyncException, we can later resume from this + * point. + * + * This method is called during every loop of rparse, and the + * arguments are the exact arguments we can pass to rparse to + * continue where we left off. + */ + protected[this] final def checkpoint(state: Int, i: Int, stack: List[FContext[J]]) { + this.state = state + this.curr = i + this.stack = stack + } + + /** + * This is a specialized accessor for the case where our underlying data are + * bytes not chars. + */ + protected[this] final def byte(i: Int): Byte = + if (i >= len) throw new AsyncException else data(i) + + // we need to signal if we got out-of-bounds + protected[this] final def at(i: Int): Char = + if (i >= len) throw new AsyncException else data(i).toChar + + /** + * Access a byte range as a string. + * + * Since the underlying data are UTF-8 encoded, i and k must occur on unicode + * boundaries. Also, the resulting String is not guaranteed to have length + * (k - i). + */ + protected[this] final def at(i: Int, k: Int): CharSequence = { + if (k > len) throw new AsyncException + val size = k - i + val arr = new Array[Byte](size) + System.arraycopy(data, i, arr, 0, size) + new String(arr, utf8) + } + + // the basic idea is that we don't signal EOF until done is true, which means + // the client explicitly send us an EOF. + protected[this] final def atEof(i: Int): Boolean = + if (done) i >= len else false + + // we don't have to do anything special on close. + protected[this] final def close(): Unit = () +} + +/** + * This class is used internally by AsyncParser to signal that we've + * reached the end of the particular input we were given. + */ +private[jawn] class AsyncException extends Exception with control.NoStackTrace + +/** + * This is a more prosaic exception which indicates that we've hit a + * parsing error. + */ +private[jawn] class FailureException extends Exception diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBasedParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBasedParser.scala new file mode 100644 index 00000000..9fc5234a --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBasedParser.scala @@ -0,0 +1,104 @@ +package jawn + +import scala.annotation.{switch, tailrec} + +/** + * Trait used when the data to be parsed is in UTF-8. + * + * This parser has to translate input bytes to Chars and Strings. It + * provides a byte() method to access individual bytes, and also + * parser strings from bytes. + * + * Its parseString() implementation has two cases. In the first case + * (the hot path) the string has no escape sequences and we can just + * UTF-8 decode the entire set of bytes. In the second case, it goes + * to some trouble to be sure to de-escape correctly given that the + * input data is UTF-8. + */ +trait ByteBasedParser[J] extends Parser[J] { + protected[this] def byte(i: Int): Byte + + /** + * See if the string has any escape sequences. If not, return the end of the + * string. If so, bail out and return -1. + * + * This method expects the data to be in UTF-8 and accesses it as bytes. Thus + * we can just ignore any bytes with the highest bit set. + */ + protected[this] final def parseStringSimple(i: Int, ctxt: FContext[J]): Int = { + var j = i + var c: Int = byte(j) & 0xff + while (c != 34) { + if (c < 32) return die(j, s"control char ($c) in string") + if (c == 92) return -1 + j += 1 + c = byte(j) & 0xff + } + j + 1 + } + + /** + * Parse the string according to JSON rules, and add to the given context. + * + * This method expects the data to be in UTF-8 and accesses it as bytes. + */ + protected[this] final def parseString(i: Int, ctxt: FContext[J]): Int = { + val k = parseStringSimple(i + 1, ctxt) + if (k != -1) { + ctxt.add(at(i + 1, k - 1)) + return k + } + + // TODO: we might be able to do better by identifying where + // escapes occur, and then translating the intermediate strings in + // one go. + + var j = i + 1 + val sb = new CharBuilder + + var c: Int = byte(j) & 0xff + while (c != 34) { // " + if (c == 92) { // \ + (byte(j + 1): @switch) match { + case 98 => { sb.append('\b'); j += 2 } + case 102 => { sb.append('\f'); j += 2 } + case 110 => { sb.append('\n'); j += 2 } + case 114 => { sb.append('\r'); j += 2 } + case 116 => { sb.append('\t'); j += 2 } + + case 34 => { sb.append('"'); j += 2 } + case 47 => { sb.append('/'); j += 2 } + case 92 => { sb.append('\\'); j += 2 } + + // if there's a problem then descape will explode + case 117 => { sb.append(descape(at(j + 2, j + 6))); j += 6 } + + case c => die(j, s"invalid escape sequence (\\${c.toChar})") + } + } else if (c < 32) { + die(j, s"control char ($c) in string") + } else if (c < 128) { + // 1-byte UTF-8 sequence + sb.append(c.toChar) + j += 1 + } else if ((c & 224) == 192) { + // 2-byte UTF-8 sequence + sb.extend(at(j, j + 2)) + j += 2 + } else if ((c & 240) == 224) { + // 3-byte UTF-8 sequence + sb.extend(at(j, j + 3)) + j += 3 + } else if ((c & 248) == 240) { + // 4-byte UTF-8 sequence + sb.extend(at(j, j + 4)) + j += 4 + } else { + die(j, "invalid UTF-8 encoding") + } + c = byte(j) & 0xff + } + ctxt.add(sb.makeString) + j + 1 + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBufferParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBufferParser.scala new file mode 100644 index 00000000..1902b8d2 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ByteBufferParser.scala @@ -0,0 +1,42 @@ +package jawn + +import scala.annotation.{switch, tailrec} +import java.nio.ByteBuffer + +/** + * Basic ByteBuffer parser. + * + * This assumes that the provided ByteBuffer is ready to be read. The + * user is responsible for any necessary flipping/resetting of the + * ByteBuffer before parsing. + * + * The parser makes absolute calls to the ByteBuffer, which will not + * update its own mutable position fields. + */ +final class ByteBufferParser[J](src: ByteBuffer) extends SyncParser[J] with ByteBasedParser[J] { + private[this] final val start = src.position + private[this] final val limit = src.limit - start + + private[this] var lineState = 0 + protected[this] def line(): Int = lineState + + protected[this] final def newline(i: Int) { lineState += 1 } + protected[this] final def column(i: Int) = i + + protected[this] final def close() { src.position(src.limit) } + protected[this] final def reset(i: Int): Int = i + protected[this] final def checkpoint(state: Int, i: Int, stack: List[FContext[J]]) {} + protected[this] final def byte(i: Int): Byte = src.get(i + start) + protected[this] final def at(i: Int): Char = src.get(i + start).toChar + + protected[this] final def at(i: Int, k: Int): CharSequence = { + val len = k - i + val arr = new Array[Byte](len) + src.position(i + start) + src.get(arr, 0, len) + src.position(start) + new String(arr, utf8) + } + + protected[this] final def atEof(i: Int) = i >= limit +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ChannelParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ChannelParser.scala new file mode 100644 index 00000000..3c93e741 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/ChannelParser.scala @@ -0,0 +1,164 @@ +package jawn + +import java.lang.Integer.{ bitCount, highestOneBit } +import java.io.{File, FileInputStream} +import java.nio.ByteBuffer +import java.nio.channels.ReadableByteChannel + +object ChannelParser { + + final val DefaultBufferSize = 1048576 + + final val ParseAsStringThreshold = 20 * 1048576 + + def fromFile[J](f: File, bufferSize: Int = DefaultBufferSize): SyncParser[J] = + if (f.length < ParseAsStringThreshold) { + val bytes = new Array[Byte](f.length.toInt) + val fis = new FileInputStream(f) + fis.read(bytes) + new StringParser[J](new String(bytes, "UTF-8")) + } else { + new ChannelParser[J](new FileInputStream(f).getChannel, bufferSize) + } + + def fromChannel[J](ch: ReadableByteChannel, bufferSize: Int = DefaultBufferSize): ChannelParser[J] = + new ChannelParser[J](ch, bufferSize) + + /** + * Given a desired buffer size, find the closest positive + * power-of-two larger than that size. + * + * This method throws an exception if the given values are negative + * or too large to have a valid power of two. + */ + def computeBufferSize(x: Int): Int = + if (x < 0) { + throw new IllegalArgumentException("negative bufferSize ($x)") + } else if (x > 0x40000000) { + throw new IllegalArgumentException("bufferSize too large ($x)") + } else if (bitCount(x) == 1) { + x + } else { + highestOneBit(x) << 1 + } +} + +/** + * Basic file parser. + * + * Given a file name this parser opens it, chunks the data, and parses + * it. + */ +final class ChannelParser[J](ch: ReadableByteChannel, bufferSize: Int) extends SyncParser[J] with ByteBasedParser[J] { + + var Bufsize: Int = ChannelParser.computeBufferSize(bufferSize) + var Mask: Int = Bufsize - 1 + var Allsize: Int = Bufsize * 2 + + // these are the actual byte arrays we'll use + private var curr = new Array[Byte](Bufsize) + private var next = new Array[Byte](Bufsize) + + // these are the bytecounts for each array + private var ncurr = ch.read(ByteBuffer.wrap(curr)) + private var nnext = ch.read(ByteBuffer.wrap(next)) + + var line = 0 + private var pos = 0 + protected[this] final def newline(i: Int): Unit = { line += 1; pos = i } + protected[this] final def column(i: Int): Int = i - pos + + protected[this] final def close(): Unit = ch.close() + + /** + * Swap the curr and next arrays/buffers/counts. + * + * We'll call this in response to certain reset() calls. Specifically, when + * the index provided to reset is no longer in the 'curr' buffer, we want to + * clear that data and swap the buffers. + */ + protected[this] final def swap(): Unit = { + var tmp = curr; curr = next; next = tmp + var ntmp = ncurr; ncurr = nnext; nnext = ntmp + } + + protected[this] final def grow(): Unit = { + val cc = new Array[Byte](Allsize) + System.arraycopy(curr, 0, cc, 0, Bufsize) + System.arraycopy(next, 0, cc, Bufsize, Bufsize) + + curr = cc + ncurr = ncurr + nnext + next = new Array[Byte](Allsize) + nnext = ch.read(ByteBuffer.wrap(next)) + + Bufsize = Allsize + Mask = Allsize - 1 + Allsize *= 2 + } + + /** + * If the cursor 'i' is past the 'curr' buffer, we want to clear the + * current byte buffer, do a swap, load some more data, and + * continue. + */ + protected[this] final def reset(i: Int): Int = + if (i >= Bufsize) { + swap() + nnext = ch.read(ByteBuffer.wrap(next)) + pos -= Bufsize + i - Bufsize + } else { + i + } + + protected[this] final def checkpoint(state: Int, i: Int, stack: List[FContext[J]]): Unit = () + + /** + * This is a specialized accessor for the case where our underlying + * data are bytes not chars. + */ + protected[this] final def byte(i: Int): Byte = + if (i < Bufsize) curr(i) + else if (i < Allsize) next(i & Mask) + else { grow(); byte(i) } + + /** + * Reads a byte as a single Char. The byte must be valid ASCII (this + * method is used to parse JSON values like numbers, constants, or + * delimiters, which are known to be within ASCII). + */ + protected[this] final def at(i: Int): Char = + if (i < Bufsize) curr(i).toChar + else if (i < Allsize) next(i & Mask).toChar + else { grow(); at(i) } + + /** + * Access a byte range as a string. + * + * Since the underlying data are UTF-8 encoded, i and k must occur + * on unicode boundaries. Also, the resulting String is not + * guaranteed to have length (k - i). + */ + protected[this] final def at(i: Int, k: Int): CharSequence = { + val len = k - i + if (k > Allsize) { + grow() + at(i, k) + } else if (k <= Bufsize) { + new String(curr, i, len, utf8) + } else if (i >= Bufsize) { + new String(next, i - Bufsize, len, utf8) + } else { + val arr = new Array[Byte](len) + val mid = Bufsize - i + System.arraycopy(curr, i, arr, 0, mid) + System.arraycopy(next, 0, arr, mid, k - Bufsize) + new String(arr, utf8) + } + } + + protected[this] final def atEof(i: Int) = + if (i < Bufsize) i >= ncurr + else i >= (nnext + Bufsize) +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBasedParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBasedParser.scala new file mode 100644 index 00000000..a054e5dc --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBasedParser.scala @@ -0,0 +1,98 @@ +package jawn + +import scala.annotation.{switch, tailrec} + +/** + * Trait used when the data to be parsed is in UTF-16. + * + * This parser provides parseString(). Like ByteBasedParser it has + * fast/slow paths for string parsing depending on whether any escapes + * are present. + * + * It is simpler than ByteBasedParser. + */ +trait CharBasedParser[J] extends Parser[J] { + + private[this] final val charBuilder = new CharBuilder() + + /** + * See if the string has any escape sequences. If not, return the + * end of the string. If so, bail out and return -1. + * + * This method expects the data to be in UTF-16 and accesses it as + * chars. + */ + protected[this] final def parseStringSimple(i: Int, ctxt: FContext[J]): Int = { + var j = i + var c = at(j) + while (c != '"') { + if (c < ' ') return die(j, s"control char (${c.toInt}) in string") + if (c == '\\') return -1 + j += 1 + c = at(j) + } + j + 1 + } + + /** + * Parse a string that is known to have escape sequences. + */ + protected[this] final def parseStringComplex(i: Int, ctxt: FContext[J]): Int = { + var j = i + 1 + val sb = charBuilder.reset() + + var c = at(j) + while (c != '"') { + if (c < ' ') { + die(j, s"control char (${c.toInt}) in string") + } else if (c == '\\') { + (at(j + 1): @switch) match { + case 'b' => { sb.append('\b'); j += 2 } + case 'f' => { sb.append('\f'); j += 2 } + case 'n' => { sb.append('\n'); j += 2 } + case 'r' => { sb.append('\r'); j += 2 } + case 't' => { sb.append('\t'); j += 2 } + + case '"' => { sb.append('"'); j += 2 } + case '/' => { sb.append('/'); j += 2 } + case '\\' => { sb.append('\\'); j += 2 } + + // if there's a problem then descape will explode + case 'u' => { sb.append(descape(at(j + 2, j + 6))); j += 6 } + + case c => die(j, s"illegal escape sequence (\\$c)") + } + } else { + // this case is for "normal" code points that are just one Char. + // + // we don't have to worry about surrogate pairs, since those + // will all be in the ranges D800–DBFF (high surrogates) or + // DC00–DFFF (low surrogates). + sb.append(c) + j += 1 + } + j = reset(j) + c = at(j) + } + ctxt.add(sb.makeString) + j + 1 + } + + /** + * Parse the string according to JSON rules, and add to the given + * context. + * + * This method expects the data to be in UTF-16, and access it as + * Char. It performs the correct checks to make sure that we don't + * interpret a multi-char code point incorrectly. + */ + protected[this] final def parseString(i: Int, ctxt: FContext[J]): Int = { + val k = parseStringSimple(i + 1, ctxt) + if (k != -1) { + ctxt.add(at(i + 1, k - 1)) + k + } else { + parseStringComplex(i, ctxt) + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBuilder.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBuilder.scala new file mode 100644 index 00000000..589437bf --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharBuilder.scala @@ -0,0 +1,56 @@ +package jawn + +/** + * CharBuilder is a specialized way to build Strings. + * + * It wraps a (growable) array of characters, and can accept + * additional String or Char data to be added to its buffer. + */ +private[jawn] final class CharBuilder { + @inline final def INITIALSIZE = 32 + + private var cs = new Array[Char](INITIALSIZE) + private var capacity = INITIALSIZE + private var len = 0 + + def reset(): CharBuilder = { + len = 0 + this + } + + def makeString: String = new String(cs, 0, len) + + def resizeIfNecessary(goal: Int): Unit = { + if (goal <= capacity) return () + var cap = capacity + while (goal > cap && cap > 0) cap *= 2 + if (cap > capacity) { + val ncs = new Array[Char](cap) + System.arraycopy(cs, 0, ncs, 0, capacity) + cs = ncs + capacity = cap + } else if (cap < capacity) { + sys.error("maximum string size exceeded") + } + } + + def extend(s: CharSequence): Unit = { + val tlen = len + s.length + resizeIfNecessary(tlen) + var i = 0 + var j = len + len = tlen + while (i < s.length) { + cs(j) = s.charAt(i) + i += 1 + j += 1 + } + } + + def append(c: Char): Unit = { + val tlen = len + 1 + resizeIfNecessary(tlen) + cs(len) = c + len = tlen + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharSequenceParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharSequenceParser.scala new file mode 100644 index 00000000..c592326e --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/CharSequenceParser.scala @@ -0,0 +1,18 @@ +package jawn + +/** + * Lazy character sequence parsing. + * + * This is similar to StringParser, but acts on character sequences. + */ +private[jawn] final class CharSequenceParser[J](cs: CharSequence) extends SyncParser[J] with CharBasedParser[J] { + var line = 0 + final def column(i: Int) = i + final def newline(i: Int) { line += 1 } + final def reset(i: Int): Int = i + final def checkpoint(state: Int, i: Int, stack: List[FContext[J]]): Unit = () + final def at(i: Int): Char = cs.charAt(i) + final def at(i: Int, j: Int): CharSequence = cs.subSequence(i, j) + final def atEof(i: Int) = i == cs.length + final def close() = () +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Facade.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Facade.scala new file mode 100644 index 00000000..203b68e9 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Facade.scala @@ -0,0 +1,34 @@ +package jawn + +/** + * Facade is a type class that describes how Jawn should construct + * JSON AST elements of type J. + * + * Facade[J] also uses FContext[J] instances, so implementors will + * usually want to define both. + */ +trait Facade[J] { + def singleContext(): FContext[J] + def arrayContext(): FContext[J] + def objectContext(): FContext[J] + + def jnull(): J + def jfalse(): J + def jtrue(): J + def jnum(s: CharSequence, decIndex: Int, expIndex: Int): J + def jstring(s: CharSequence): J +} + +/** + * FContext is used to construct nested JSON values. + * + * The most common cases are to build objects and arrays. However, + * this type is also used to build a single top-level JSON element, in + * cases where the entire JSON document consists of "333.33". + */ +trait FContext[J] { + def add(s: CharSequence): Unit + def add(v: J): Unit + def finish: J + def isObj: Boolean +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/MutableFacade.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/MutableFacade.scala new file mode 100644 index 00000000..8fe5716b --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/MutableFacade.scala @@ -0,0 +1,35 @@ +package jawn + +import scala.collection.mutable + +trait MutableFacade[J] extends Facade[J] { + def jarray(vs: mutable.ArrayBuffer[J]): J + def jobject(vs: mutable.Map[String, J]): J + + def singleContext() = new FContext[J] { + var value: J = _ + def add(s: CharSequence) { value = jstring(s) } + def add(v: J) { value = v } + def finish: J = value + def isObj: Boolean = false + } + + def arrayContext() = new FContext[J] { + val vs = mutable.ArrayBuffer.empty[J] + def add(s: CharSequence) { vs.append(jstring(s)) } + def add(v: J) { vs.append(v) } + def finish: J = jarray(vs) + def isObj: Boolean = false + } + + def objectContext() = new FContext[J] { + var key: String = null + val vs = mutable.Map.empty[String, J] + def add(s: CharSequence): Unit = + if (key == null) { key = s.toString } else { vs(key) = jstring(s); key = null } + def add(v: J): Unit = + { vs(key) = v; key = null } + def finish = jobject(vs) + def isObj = true + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/NullFacade.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/NullFacade.scala new file mode 100644 index 00000000..39d55884 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/NullFacade.scala @@ -0,0 +1,30 @@ +package jawn + +/** + * NullFacade discards all JSON AST information. + * + * This is the simplest possible facade. It could be useful for + * checking JSON for correctness (via parsing) without worrying about + * saving the data. + * + * It will always return () on any successful parse, no matter the + * content. + */ +object NullFacade extends Facade[Unit] { + + case class NullContext(isObj: Boolean) extends FContext[Unit] { + def add(s: CharSequence): Unit = () + def add(v: Unit): Unit = () + def finish: Unit = () + } + + val singleContext: FContext[Unit] = NullContext(false) + val arrayContext: FContext[Unit] = NullContext(false) + val objectContext: FContext[Unit] = NullContext(true) + + def jnull(): Unit = () + def jfalse(): Unit = () + def jtrue(): Unit = () + def jnum(s: CharSequence, decIndex: Int, expIndex: Int): Unit = () + def jstring(s: CharSequence): Unit = () +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Parser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Parser.scala new file mode 100644 index 00000000..1177e91f --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Parser.scala @@ -0,0 +1,507 @@ +package jawn + +import java.io.File +import java.nio.ByteBuffer +import java.nio.channels.ReadableByteChannel +import java.nio.charset.Charset +import scala.annotation.{switch, tailrec} +import scala.util.Try + +case class ParseException(msg: String, index: Int, line: Int, col: Int) extends Exception(msg) + +case class IncompleteParseException(msg: String) extends Exception(msg) + +/** + * Parser implements a state machine for correctly parsing JSON data. + * + * The trait relies on a small number of methods which are left + * abstract, and which generalize parsing based on whether the input + * is in Bytes or Chars, coming from Strings, files, or other input. + * All methods provided here are protected, so different parsers can + * choose which functionality to expose. + * + * Parser is parameterized on J, which is the type of the JSON AST it + * will return. Jawn can produce any AST for which a Facade[J] is + * available. + * + * The parser trait does not hold any state itself, but particular + * implementations will usually hold state. Parser instances should + * not be reused between parsing runs. + * + * For now the parser requires input to be in UTF-8. This requirement + * may eventually be relaxed. + */ +abstract class Parser[J] { + + protected[this] final val utf8 = Charset.forName("UTF-8") + + /** + * Read the byte/char at 'i' as a Char. + * + * Note that this should not be used on potential multi-byte + * sequences. + */ + protected[this] def at(i: Int): Char + + /** + * Read the bytes/chars from 'i' until 'j' as a String. + */ + protected[this] def at(i: Int, j: Int): CharSequence + + /** + * Return true iff 'i' is at or beyond the end of the input (EOF). + */ + protected[this] def atEof(i: Int): Boolean + + /** + * The reset() method is used to signal that we're working from the + * given position, and any previous data can be released. Some + * parsers (e.g. StringParser) will ignore release, while others + * (e.g. PathParser) will need to use this information to release + * and allocate different areas. + */ + protected[this] def reset(i: Int): Int + + /** + * The checkpoint() method is used to allow some parsers to store + * their progress. + */ + protected[this] def checkpoint(state: Int, i: Int, stack: List[FContext[J]]): Unit + + /** + * Should be called when parsing is finished. + */ + protected[this] def close(): Unit + + /** + * Valid parser states. + */ + @inline protected[this] final val ARRBEG = 6 + @inline protected[this] final val OBJBEG = 7 + @inline protected[this] final val DATA = 1 + @inline protected[this] final val KEY = 2 + @inline protected[this] final val SEP = 3 + @inline protected[this] final val ARREND = 4 + @inline protected[this] final val OBJEND = 5 + + protected[this] def newline(i: Int): Unit + protected[this] def line(): Int + protected[this] def column(i: Int): Int + + protected[this] final val HexChars: Array[Int] = { + val arr = new Array[Int](128) + var i = 0 + while (i < 10) { arr(i + '0') = i; i += 1 } + i = 0 + while (i < 16) { arr(i + 'a') = 10 + i; arr(i + 'A') = 10 + i; i += 1 } + arr + } + + /** + * Used to generate error messages with character info and offsets. + */ + protected[this] def die(i: Int, msg: String): Nothing = { + val y = line() + 1 + val x = column(i) + 1 + val s = "%s got %s (line %d, column %d)" format (msg, at(i), y, x) + throw ParseException(s, i, y, x) + } + + /** + * Used to generate messages for internal errors. + * + * This should only be used in situations where a possible bug in + * the parser was detected. For errors in user-provided JSON, use + * die(). + */ + protected[this] def error(msg: String) = + sys.error(msg) + + /** + * Parse the given number, and add it to the given context. + * + * We don't actually instantiate a number here, but rather pass the + * string of for future use. Facades can choose to be lazy and just + * store the string. This ends up being way faster and has the nice + * side-effect that we know exactly how the user represented the + * number. + */ + protected[this] final def parseNum(i: Int, ctxt: FContext[J])(implicit facade: Facade[J]): Int = { + var j = i + var c = at(j) + var decIndex = -1 + var expIndex = -1 + + if (c == '-') { + j += 1 + c = at(j) + } + if (c == '0') { + j += 1 + c = at(j) + } else if ('1' <= c && c <= '9') { + while ('0' <= c && c <= '9') { j += 1; c = at(j) } + } else { + die(i, "expected digit") + } + + if (c == '.') { + decIndex = j - i + j += 1 + c = at(j) + if ('0' <= c && c <= '9') { + while ('0' <= c && c <= '9') { j += 1; c = at(j) } + } else { + die(i, "expected digit") + } + } + + if (c == 'e' || c == 'E') { + expIndex = j - i + j += 1 + c = at(j) + if (c == '+' || c == '-') { + j += 1 + c = at(j) + } + if ('0' <= c && c <= '9') { + while ('0' <= c && c <= '9') { j += 1; c = at(j) } + } else { + die(i, "expected digit") + } + } + + ctxt.add(facade.jnum(at(i, j), decIndex, expIndex)) + j + } + + /** + * Parse the given number, and add it to the given context. + * + * This method is a bit slower than parseNum() because it has to be + * sure it doesn't run off the end of the input. + * + * Normally (when operating in rparse in the context of an outer + * array or object) we don't need to worry about this and can just + * grab characters, because if we run out of characters that would + * indicate bad input. This is for cases where the number could + * possibly be followed by a valid EOF. + * + * This method has all the same caveats as the previous method. + */ + protected[this] final def parseNumSlow(i: Int, ctxt: FContext[J])(implicit facade: Facade[J]): Int = { + var j = i + var c = at(j) + var decIndex = -1 + var expIndex = -1 + + if (c == '-') { + // any valid input will require at least one digit after - + j += 1 + c = at(j) + } + if (c == '0') { + j += 1 + if (atEof(j)) { + ctxt.add(facade.jnum(at(i, j), decIndex, expIndex)) + return j + } + c = at(j) + } else if ('1' <= c && c <= '9') { + while ('0' <= c && c <= '9') { + j += 1 + if (atEof(j)) { + ctxt.add(facade.jnum(at(i, j), decIndex, expIndex)) + return j + } + c = at(j) + } + } else { + die(i, "expected digit") + } + + if (c == '.') { + // any valid input will require at least one digit after . + decIndex = j - i + j += 1 + c = at(j) + if ('0' <= c && c <= '9') { + while ('0' <= c && c <= '9') { + j += 1 + if (atEof(j)) { + ctxt.add(facade.jnum(at(i, j), decIndex, expIndex)) + return j + } + c = at(j) + } + } else { + die(i, "expected digit") + } + } + + if (c == 'e' || c == 'E') { + // any valid input will require at least one digit after e, e+, etc + expIndex = j - i + j += 1 + c = at(j) + if (c == '+' || c == '-') { + j += 1 + c = at(j) + } + if ('0' <= c && c <= '9') { + while ('0' <= c && c <= '9') { + j += 1 + if (atEof(j)) { + ctxt.add(facade.jnum(at(i, j), decIndex, expIndex)) + return j + } + c = at(j) + } + } else { + die(i, "expected digit") + } + } + + ctxt.add(facade.jnum(at(i, j), decIndex, expIndex)) + j + } + + /** + * Generate a Char from the hex digits of "\u1234" (i.e. "1234"). + * + * NOTE: This is only capable of generating characters from the basic plane. + * This is why it can only return Char instead of Int. + */ + protected[this] final def descape(s: CharSequence): Char = { + val hc = HexChars + var i = 0 + var x = 0 + while (i < 4) { + x = (x << 4) | hc(s.charAt(i).toInt) + i += 1 + } + x.toChar + } + + /** + * Parse the JSON string starting at 'i' and save it into 'ctxt'. + */ + protected[this] def parseString(i: Int, ctxt: FContext[J]): Int + + /** + * Parse the JSON constant "true". + * + * Note that this method assumes that the first character has already been checked. + */ + protected[this] final def parseTrue(i: Int)(implicit facade: Facade[J]): J = + if (at(i + 1) == 'r' && at(i + 2) == 'u' && at(i + 3) == 'e') { + facade.jtrue + } else { + die(i, "expected true") + } + + /** + * Parse the JSON constant "false". + * + * Note that this method assumes that the first character has already been checked. + */ + protected[this] final def parseFalse(i: Int)(implicit facade: Facade[J]): J = + if (at(i + 1) == 'a' && at(i + 2) == 'l' && at(i + 3) == 's' && at(i + 4) == 'e') { + facade.jfalse + } else { + die(i, "expected false") + } + + /** + * Parse the JSON constant "null". + * + * Note that this method assumes that the first character has already been checked. + */ + protected[this] final def parseNull(i: Int)(implicit facade: Facade[J]): J = + if (at(i + 1) == 'u' && at(i + 2) == 'l' && at(i + 3) == 'l') { + facade.jnull + } else { + die(i, "expected null") + } + + /** + * Parse and return the next JSON value and the position beyond it. + */ + protected[this] final def parse(i: Int)(implicit facade: Facade[J]): (J, Int) = try { + (at(i): @switch) match { + // ignore whitespace + case ' ' => parse(i + 1) + case '\t' => parse(i + 1) + case '\r' => parse(i + 1) + case '\n' => newline(i); parse(i + 1) + + // if we have a recursive top-level structure, we'll delegate the parsing + // duties to our good friend rparse(). + case '[' => rparse(ARRBEG, i + 1, facade.arrayContext() :: Nil) + case '{' => rparse(OBJBEG, i + 1, facade.objectContext() :: Nil) + + // we have a single top-level number + case '-' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' => + val ctxt = facade.singleContext() + val j = parseNumSlow(i, ctxt) + (ctxt.finish, j) + + // we have a single top-level string + case '"' => + val ctxt = facade.singleContext() + val j = parseString(i, ctxt) + (ctxt.finish, j) + + // we have a single top-level constant + case 't' => (parseTrue(i), i + 4) + case 'f' => (parseFalse(i), i + 5) + case 'n' => (parseNull(i), i + 4) + + // invalid + case _ => die(i, "expected json value") + } + } catch { + case _: IndexOutOfBoundsException => + throw IncompleteParseException("exhausted input") + } + + /** + * Tail-recursive parsing method to do the bulk of JSON parsing. + * + * This single method manages parser states, data, etc. Except for + * parsing non-recursive values (like strings, numbers, and + * constants) all important work happens in this loop (or in methods + * it calls, like reset()). + * + * Currently the code is optimized to make use of switch + * statements. Future work should consider whether this is better or + * worse than manually constructed if/else statements or something + * else. Also, it may be possible to reorder some cases for speed + * improvements. + */ + @tailrec + protected[this] final def rparse(state: Int, j: Int, stack: List[FContext[J]])(implicit facade: Facade[J]): (J, Int) = { + val i = reset(j) + checkpoint(state, i, stack) + + val c = at(i) + + if (c == '\n') { + newline(i) + rparse(state, i + 1, stack) + } else if (c == ' ' || c == '\t' || c == '\r') { + rparse(state, i + 1, stack) + } else if (state == DATA) { + // we are inside an object or array expecting to see data + if (c == '[') { + rparse(ARRBEG, i + 1, facade.arrayContext() :: stack) + } else if (c == '{') { + rparse(OBJBEG, i + 1, facade.objectContext() :: stack) + } else { + val ctxt = stack.head + + if ((c >= '0' && c <= '9') || c == '-') { + val j = parseNum(i, ctxt) + rparse(if (ctxt.isObj) OBJEND else ARREND, j, stack) + } else if (c == '"') { + val j = parseString(i, ctxt) + rparse(if (ctxt.isObj) OBJEND else ARREND, j, stack) + } else if (c == 't') { + ctxt.add(parseTrue(i)) + rparse(if (ctxt.isObj) OBJEND else ARREND, i + 4, stack) + } else if (c == 'f') { + ctxt.add(parseFalse(i)) + rparse(if (ctxt.isObj) OBJEND else ARREND, i + 5, stack) + } else if (c == 'n') { + ctxt.add(parseNull(i)) + rparse(if (ctxt.isObj) OBJEND else ARREND, i + 4, stack) + } else { + die(i, "expected json value") + } + } + } else if ( + (c == ']' && (state == ARREND || state == ARRBEG)) || + (c == '}' && (state == OBJEND || state == OBJBEG)) + ) { + // we are inside an array or object and have seen a key or a closing + // brace, respectively. + if (stack.isEmpty) { + error("invalid stack") + } else { + val ctxt1 = stack.head + val tail = stack.tail + + if (tail.isEmpty) { + (ctxt1.finish, i + 1) + } else { + val ctxt2 = tail.head + ctxt2.add(ctxt1.finish) + rparse(if (ctxt2.isObj) OBJEND else ARREND, i + 1, tail) + } + } + } else if (state == KEY) { + // we are in an object expecting to see a key. + if (c == '"') { + val j = parseString(i, stack.head) + rparse(SEP, j, stack) + } else { + die(i, "expected \"") + } + } else if (state == SEP) { + // we are in an object just after a key, expecting to see a colon. + if (c == ':') { + rparse(DATA, i + 1, stack) + } else { + die(i, "expected :") + } + } else if (state == ARREND) { + // we are in an array, expecting to see a comma (before more data). + if (c == ',') { + rparse(DATA, i + 1, stack) + } else { + die(i, "expected ] or ,") + } + } else if (state == OBJEND) { + // we are in an object, expecting to see a comma (before more data). + if (c == ',') { + rparse(KEY, i + 1, stack) + } else { + die(i, "expected } or ,") + } + } else if (state == ARRBEG) { + // we are starting an array, expecting to see data or a closing bracket. + rparse(DATA, i, stack) + } else { + // we are starting an object, expecting to see a key or a closing brace. + rparse(KEY, i, stack) + } + } +} + + +object Parser { + + def parseUnsafe[J](s: String)(implicit facade: Facade[J]): J = + new StringParser(s).parse() + + def parseFromString[J](s: String)(implicit facade: Facade[J]): Try[J] = + Try(new StringParser[J](s).parse) + + def parseFromCharSequence[J](cs: CharSequence)(implicit facade: Facade[J]): Try[J] = + Try(new CharSequenceParser[J](cs).parse) + + def parseFromPath[J](path: String)(implicit facade: Facade[J]): Try[J] = + Try(ChannelParser.fromFile[J](new File(path)).parse) + + def parseFromFile[J](file: File)(implicit facade: Facade[J]): Try[J] = + Try(ChannelParser.fromFile[J](file).parse) + + def parseFromChannel[J](ch: ReadableByteChannel)(implicit facade: Facade[J]): Try[J] = + Try(ChannelParser.fromChannel[J](ch).parse) + + def parseFromByteBuffer[J](buf: ByteBuffer)(implicit facade: Facade[J]): Try[J] = + Try(new ByteBufferParser[J](buf).parse) + + def async[J](mode: AsyncParser.Mode)(implicit facade: Facade[J]): AsyncParser[J] = + AsyncParser[J](mode) +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SimpleFacade.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SimpleFacade.scala new file mode 100644 index 00000000..dabec016 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SimpleFacade.scala @@ -0,0 +1,42 @@ +package jawn + +import scala.collection.mutable + +/** + * Facade is a type class that describes how Jawn should construct + * JSON AST elements of type J. + * + * Facade[J] also uses FContext[J] instances, so implementors will + * usually want to define both. + */ +trait SimpleFacade[J] extends Facade[J] { + def jarray(vs: List[J]): J + def jobject(vs: Map[String, J]): J + + def singleContext() = new FContext[J] { + var value: J = _ + def add(s: CharSequence) { value = jstring(s) } + def add(v: J) { value = v } + def finish: J = value + def isObj: Boolean = false + } + + def arrayContext() = new FContext[J] { + val vs = mutable.ListBuffer.empty[J] + def add(s: CharSequence) { vs += jstring(s) } + def add(v: J) { vs += v } + def finish: J = jarray(vs.toList) + def isObj: Boolean = false + } + + def objectContext() = new FContext[J] { + var key: String = null + var vs = Map.empty[String, J] + def add(s: CharSequence): Unit = + if (key == null) { key = s.toString } else { vs = vs.updated(key, jstring(s)); key = null } + def add(v: J): Unit = + { vs = vs.updated(key, v); key = null } + def finish = jobject(vs) + def isObj = true + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/StringParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/StringParser.scala new file mode 100644 index 00000000..91662fc0 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/StringParser.scala @@ -0,0 +1,25 @@ +package jawn + +/** + * Basic in-memory string parsing. + * + * This is probably the simplest Parser implementation, since there is + * no UTF-8 decoding, and the data is already fully available. + * + * This parser is limited to the maximum string size (~2G). Obviously + * for large JSON documents it's better to avoid using this parser and + * go straight from disk, to avoid having to load the whole thing into + * memory at once. So this limit will probably not be a problem in + * practice. + */ +private[jawn] final class StringParser[J](s: String) extends SyncParser[J] with CharBasedParser[J] { + var line = 0 + final def column(i: Int) = i + final def newline(i: Int) { line += 1 } + final def reset(i: Int): Int = i + final def checkpoint(state: Int, i: Int, stack: List[FContext[J]]): Unit = () + final def at(i: Int): Char = s.charAt(i) + final def at(i: Int, j: Int): CharSequence = s.substring(i, j) + final def atEof(i: Int) = i == s.length + final def close() = () +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SupportParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SupportParser.scala new file mode 100644 index 00000000..2304a8dd --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SupportParser.scala @@ -0,0 +1,31 @@ +package jawn + +import java.io.File +import java.nio.ByteBuffer +import java.nio.channels.ReadableByteChannel +import scala.util.Try + +trait SupportParser[J] { + implicit def facade: Facade[J] + + def parseUnsafe(s: String): J = + new StringParser(s).parse() + + def parseFromString(s: String): Try[J] = + Try(new StringParser[J](s).parse) + + def parseFromPath(path: String): Try[J] = + Try(ChannelParser.fromFile[J](new File(path)).parse) + + def parseFromFile(file: File): Try[J] = + Try(ChannelParser.fromFile[J](file).parse) + + def parseFromChannel(ch: ReadableByteChannel): Try[J] = + Try(ChannelParser.fromChannel[J](ch).parse) + + def parseFromByteBuffer(buf: ByteBuffer): Try[J] = + Try(new ByteBufferParser[J](buf).parse) + + def async(mode: AsyncParser.Mode): AsyncParser[J] = + AsyncParser[J](mode) +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SyncParser.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SyncParser.scala new file mode 100644 index 00000000..988a8ca9 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/SyncParser.scala @@ -0,0 +1,37 @@ +package jawn + +import scala.annotation.{switch, tailrec} +import scala.collection.mutable + +/** + * SyncParser extends Parser to do all parsing synchronously. + * + * Most traditional JSON parser are synchronous, and expect to receive + * all their input before returning. SyncParser[J] still leaves + * Parser[J]'s methods abstract, but adds a public methods for users + * to call to actually parse JSON. + */ +abstract class SyncParser[J] extends Parser[J] { + + /** + * Parse the JSON document into a single JSON value. + * + * The parser considers documents like '333', 'true', and '"foo"' to be + * valid, as well as more traditional documents like [1,2,3,4,5]. However, + * multiple top-level objects are not allowed. + */ + final def parse()(implicit facade: Facade[J]): J = { + val (value, i) = parse(0) + var j = i + while (!atEof(j)) { + (at(j): @switch) match { + case '\n' => newline(j); j += 1 + case ' ' | '\t' | '\r' => j += 1 + case _ => die(j, "expected whitespace or eof") + } + } + if (!atEof(j)) die(j, "expected eof") + close() + value + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Syntax.scala b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Syntax.scala new file mode 100644 index 00000000..119b5783 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/main/scala/jawn/Syntax.scala @@ -0,0 +1,27 @@ +package jawn + +import java.io.File +import java.nio.ByteBuffer +import java.nio.channels.ReadableByteChannel +import java.nio.charset.Charset +import scala.annotation.{switch, tailrec} +import scala.util.Try + +object Syntax { + implicit def unitFacade: Facade[Unit] = NullFacade + + def checkString(s: String): Boolean = + Try(new StringParser(s).parse).isSuccess + + def checkPath(path: String): Boolean = + Try(ChannelParser.fromFile(new File(path)).parse).isSuccess + + def checkFile(file: File): Boolean = + Try(ChannelParser.fromFile(file).parse).isSuccess + + def checkChannel(ch: ReadableByteChannel): Boolean = + Try(ChannelParser.fromChannel(ch).parse).isSuccess + + def checkByteBuffer(buf: ByteBuffer): Boolean = + Try(new ByteBufferParser(buf).parse).isSuccess +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/ChannelSpec.scala b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/ChannelSpec.scala new file mode 100644 index 00000000..6d5d33a9 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/ChannelSpec.scala @@ -0,0 +1,25 @@ +package jawn +package parser + +import org.scalatest._ + +import java.nio.channels.ByteChannel +import scala.util.Success + +class ChannelSpec extends PropSpec with Matchers { + + property("large strings in files are ok") { + val M = 1000000 + val q = "\"" + val big = q + ("x" * (40 * M)) + q + val bigEscaped = q + ("\\\\" * (20 * M)) + q + + TestUtil.withTemp(big) { t => + Parser.parseFromFile(t)(NullFacade).isSuccess shouldBe true + } + + TestUtil.withTemp(bigEscaped) { t => + Parser.parseFromFile(t)(NullFacade).isSuccess shouldBe true + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/CharBuilderSpec.scala b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/CharBuilderSpec.scala new file mode 100644 index 00000000..b25e67fe --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/CharBuilderSpec.scala @@ -0,0 +1,23 @@ +package jawn + +import org.scalatest._ +import org.scalatest.prop._ + +class CharBuilderSpec extends PropSpec with Matchers with PropertyChecks { + + property("append") { + forAll { xs: List[Char] => + val builder = new CharBuilder + xs.foreach(builder.append) + builder.makeString shouldBe xs.mkString + } + } + + property("extend") { + forAll { xs: List[String] => + val builder = new CharBuilder + xs.foreach(builder.extend) + builder.makeString shouldBe xs.mkString + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/JNumIndexCheck.scala b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/JNumIndexCheck.scala new file mode 100644 index 00000000..b0b6568d --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/JNumIndexCheck.scala @@ -0,0 +1,81 @@ +package jawn +package parser + +import java.nio.ByteBuffer +import org.scalatest.{Matchers, PropSpec} +import org.scalatest.prop.PropertyChecks +import scala.util.Success + +class JNumIndexCheck extends PropSpec with Matchers with PropertyChecks { + object JNumIndexCheckFacade extends Facade[Boolean] { + class JNumIndexCheckContext(val isObj: Boolean) extends FContext[Boolean] { + var failed = false + def add(s: CharSequence): Unit = () + def add(v: Boolean): Unit = { + if (!v) failed = true + } + def finish: Boolean = !failed + } + + val singleContext: FContext[Boolean] = new JNumIndexCheckContext(false) + val arrayContext: FContext[Boolean] = new JNumIndexCheckContext(false) + val objectContext: FContext[Boolean] = new JNumIndexCheckContext(true) + + def jnull(): Boolean = true + def jfalse(): Boolean = true + def jtrue(): Boolean = true + def jnum(s: CharSequence, decIndex: Int, expIndex: Int): Boolean = { + val input = s.toString + val inputDecIndex = input.indexOf('.') + val inputExpIndex = if (input.indexOf('e') == -1) input.indexOf("E") else input.indexOf('e') + + decIndex == inputDecIndex && expIndex == inputExpIndex + } + def jstring(s: CharSequence): Boolean = true + } + + property("jnum provides the correct indices with parseFromString") { + forAll { (value: BigDecimal) => + val json = s"""{ "num": ${value.toString} }""" + Parser.parseFromString(json)(JNumIndexCheckFacade) shouldBe Success(true) + } + } + + property("jnum provides the correct indices with parseFromByteBuffer") { + forAll { (value: BigDecimal) => + val json = s"""{ "num": ${value.toString} }""" + val bb = ByteBuffer.wrap(json.getBytes("UTF-8")) + Parser.parseFromByteBuffer(bb)(JNumIndexCheckFacade) shouldBe Success(true) + } + } + + property("jnum provides the correct indices with parseFromFile") { + forAll { (value: BigDecimal) => + val json = s"""{ "num": ${value.toString} }""" + TestUtil.withTemp(json) { t => + Parser.parseFromFile(t)(JNumIndexCheckFacade) shouldBe Success(true) + } + } + } + + property("jnum provides the correct indices at the top level with parseFromString") { + forAll { (value: BigDecimal) => + Parser.parseFromString(value.toString)(JNumIndexCheckFacade) shouldBe Success(true) + } + } + + property("jnum provides the correct indices at the top level with parseFromByteBuffer") { + forAll { (value: BigDecimal) => + val bb = ByteBuffer.wrap(value.toString.getBytes("UTF-8")) + Parser.parseFromByteBuffer(bb)(JNumIndexCheckFacade) shouldBe Success(true) + } + } + + property("jnum provides the correct indices at the top level with parseFromFile") { + forAll { (value: BigDecimal) => + TestUtil.withTemp(value.toString) { t => + Parser.parseFromFile(t)(JNumIndexCheckFacade) shouldBe Success(true) + } + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/SyntaxCheck.scala b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/SyntaxCheck.scala new file mode 100644 index 00000000..fd00c260 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/SyntaxCheck.scala @@ -0,0 +1,131 @@ +package jawn +package parser + +import org.scalatest._ +import prop._ +import org.scalacheck.Arbitrary._ +import org.scalacheck._ +import Gen._ +import Arbitrary.arbitrary + +import scala.util.{Try, Success, Failure} + +class SyntaxCheck extends PropSpec with Matchers with PropertyChecks { + + sealed trait J { + def build: String = this match { + case JAtom(s) => s + case JArray(js) => js.map(_.build).mkString("[", ",", "]") + case JObject(js) => js.map { case (k, v) => + val kk = "\"" + k + "\"" + val vv = v.build + s"$kk: $vv" + }.mkString("{", ",", "}") + } + } + + case class JAtom(s: String) extends J + case class JArray(js: List[J]) extends J + case class JObject(js: Map[String, J]) extends J + + val jatom: Gen[JAtom] = + Gen.oneOf( + "null", "true", "false", "1234", "-99", "16.0", "2e9", + "-4.44E-10", "11e+14", "\"foo\"", "\"\"", "\"bar\"", + "\"qux\"", "\"duh\"", "\"abc\"", "\"xyz\"", "\"zzzzzz\"", + "\"\\u1234\"").map(JAtom(_)) + + def jarray(lvl: Int): Gen[JArray] = + Gen.containerOf[List, J](jvalue(lvl + 1)).map(JArray(_)) + + val keys = Gen.oneOf("foo", "bar", "qux", "abc", "def", "xyz") + def jitem(lvl: Int): Gen[(String, J)] = + for { s <- keys; j <- jvalue(lvl) } yield (s, j) + + def jobject(lvl: Int): Gen[JObject] = + Gen.containerOf[List, (String, J)](jitem(lvl + 1)).map(ts => JObject(ts.toMap)) + + def jvalue(lvl: Int): Gen[J] = + if (lvl < 3) { + Gen.frequency((16, 'ato), (1, 'arr), (2, 'obj)).flatMap { + case 'ato => jatom + case 'arr => jarray(lvl) + case 'obj => jobject(lvl) + } + } else { + jatom + } + + implicit lazy val arbJValue: Arbitrary[J] = + Arbitrary(jvalue(0)) + + import java.nio.ByteBuffer + + def isValidSyntax(s: String): Boolean = { + val cs = java.nio.CharBuffer.wrap(s.toCharArray) + val r0 = Parser.parseFromCharSequence(cs)(NullFacade).isSuccess + val r1 = Parser.parseFromString(s)(NullFacade).isSuccess + val bb = ByteBuffer.wrap(s.getBytes("UTF-8")) + val r2 = Parser.parseFromByteBuffer(bb)(NullFacade).isSuccess + if (r0 == r1) r1 else sys.error(s"CharSequence/String parsing disagree($r0, $r1): $s") + if (r1 == r2) r1 else sys.error(s"String/ByteBuffer parsing disagree($r1, $r2): $s") + + TestUtil.withTemp(s) { t => + Parser.parseFromFile(t)(NullFacade).isSuccess + } + + val async = AsyncParser[Unit](AsyncParser.SingleValue) + val r3 = async.absorb(s)(NullFacade).isRight && async.finish()(NullFacade).isRight + if (r1 == r3) r1 else sys.error(s"Sync/Async parsing disagree($r1, $r3): $s") + } + + property("syntax-checking") { + forAll { (j: J) => isValidSyntax(j.build) shouldBe true } + } + + def qs(s: String): String = "\"" + s + "\"" + + property("unicode is ok") { + isValidSyntax(qs("ö")) shouldBe true + isValidSyntax(qs("ö\\\\")) shouldBe true + isValidSyntax(qs("\\\\ö")) shouldBe true + } + + property("literal TAB is invalid") { isValidSyntax(qs("\t")) shouldBe false } + property("literal NL is invalid") { isValidSyntax(qs("\n")) shouldBe false } + property("literal CR is invalid") { isValidSyntax(qs("\r")) shouldBe false } + property("literal NUL is invalid") { isValidSyntax(qs("\u0000")) shouldBe false } + property("literal BS TAB is invalid") { isValidSyntax(qs("\\\t")) shouldBe false } + property("literal BS NL is invalid") { isValidSyntax(qs("\\\n")) shouldBe false } + property("literal BS CR is invalid") { isValidSyntax(qs("\\\r")) shouldBe false } + property("literal BS NUL is invalid") { isValidSyntax(qs("\\\u0000")) shouldBe false } + property("literal BS ZERO is invalid") { isValidSyntax(qs("\\0")) shouldBe false } + property("literal BS X is invalid") { isValidSyntax(qs("\\x")) shouldBe false } + + property("0 is ok") { isValidSyntax("0") shouldBe true } + property("0e is invalid") { isValidSyntax("0e") shouldBe false } + property("123e is invalid") { isValidSyntax("123e") shouldBe false } + property(".999 is invalid") { isValidSyntax(".999") shouldBe false } + property("0.999 is ok") { isValidSyntax("0.999") shouldBe true } + property("-.999 is invalid") { isValidSyntax("-.999") shouldBe false } + property("-0.999 is ok") { isValidSyntax("-0.999") shouldBe true } + property("+0.999 is invalid") { isValidSyntax("+0.999") shouldBe false } + property("--0.999 is invalid") { isValidSyntax("--0.999") shouldBe false } + property("01 is invalid") { isValidSyntax("01") shouldBe false } + property("1e is invalid") { isValidSyntax("1e") shouldBe false } + property("1e- is invalid") { isValidSyntax("1e+") shouldBe false } + property("1e+ is invalid") { isValidSyntax("1e-") shouldBe false } + property("1. is invalid") { isValidSyntax("1.") shouldBe false } + property("1.e is invalid") { isValidSyntax("1.e") shouldBe false } + property("1.e9 is invalid") { isValidSyntax("1.e9") shouldBe false } + property("1.e- is invalid") { isValidSyntax("1.e+") shouldBe false } + property("1.e+ is invalid") { isValidSyntax("1.e-") shouldBe false } + property("1.1e is invalid") { isValidSyntax("1.1e") shouldBe false } + property("1.1e- is invalid") { isValidSyntax("1.1e-") shouldBe false } + property("1.1e+ is invalid") { isValidSyntax("1.1e+") shouldBe false } + property("1.1e1 is ok") { isValidSyntax("1.1e1") shouldBe true } + property("1.1e-1 is ok") { isValidSyntax("1.1e-1") shouldBe true } + property("1.1e+1 is ok") { isValidSyntax("1.1e+1") shouldBe true } + property("1+ is invalid") { isValidSyntax("1+") shouldBe false } + property("1- is invalid") { isValidSyntax("1-") shouldBe false } +} diff --git a/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/TestUtil.scala b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/TestUtil.scala new file mode 100644 index 00000000..64b8dd59 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/parser/src/test/scala/jawn/TestUtil.scala @@ -0,0 +1,18 @@ +package jawn +package parser + +import java.io._ + +object TestUtil { + def withTemp[A](s: String)(f: File => A): A = { + val t = File.createTempFile("jawn-syntax", ".json") + val pw = new PrintWriter(t) + pw.println(s) + pw.close() + try { + f(t) + } finally { + t.delete() + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/project/ReleaseHelper.scala b/scalaplugin/src/test/resource/jawn/project/ReleaseHelper.scala new file mode 100644 index 00000000..354d6506 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/project/ReleaseHelper.scala @@ -0,0 +1,34 @@ +import sbt._ +import sbt.Keys._ +import sbt.complete.Parser + +object ReleaseHelper { + + /** Invoke a command and carry out remaining commands until completion. + * + * This is necessary because sbt-release's releaseStepCommand does not + * execute remaining commands, which sbt-doge relies on. + * + * Based on https://github.com/playframework/playframework/blob/master/framework/project/Release.scala + * + * NOTE: This can be removed in favor of https://github.com/sbt/sbt-release/pull/171 if/when merged upstream + */ + def runCommandAndRemaining(command: String): State => State = { originalState => + val originalRemaining = originalState.remainingCommands + + @annotation.tailrec + def runCommand(command: String, state: State): State = { + val newState = Parser.parse(command, state.combinedParser) match { + case Right(cmd) => cmd() + case Left(msg) => throw sys.error(s"Invalid programmatic input:\n$msg") + } + if (newState.remainingCommands.isEmpty) { + newState + } else { + runCommand(newState.remainingCommands.head, newState.copy(remainingCommands = newState.remainingCommands.tail)) + } + } + + runCommand(command, originalState.copy(remainingCommands = Nil)).copy(remainingCommands = originalRemaining) + } +} diff --git a/scalaplugin/src/test/resource/jawn/project/build.properties b/scalaplugin/src/test/resource/jawn/project/build.properties new file mode 100644 index 00000000..64317fda --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/project/build.properties @@ -0,0 +1 @@ +sbt.version=0.13.15 diff --git a/scalaplugin/src/test/resource/jawn/project/plugins.sbt b/scalaplugin/src/test/resource/jawn/project/plugins.sbt new file mode 100644 index 00000000..618876a9 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/project/plugins.sbt @@ -0,0 +1,6 @@ +addSbtPlugin("com.eed3si9n" % "sbt-doge" % "0.1.5") +addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.2.25") +addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.14") +addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.1") +addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.5") +addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "1.1") diff --git a/scalaplugin/src/test/resource/jawn/randjson.py b/scalaplugin/src/test/resource/jawn/randjson.py new file mode 100644 index 00000000..1783eba5 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/randjson.py @@ -0,0 +1,78 @@ +import json +import os +from random import * +import string +import sys + +constants = [True, False, None] + +def mkconstant(): + return choice(constants) + +def mkinteger(): + return randint(-1e3, 1e3) * (10 ** normalvariate(0, 4)) + randint(-1e3, 1e3) + +def mkdouble(): + return random() * (10 ** normalvariate(0, 30)) + +def mknum(): + if randint(0, 1): + return mkdouble() + else: + return mkinteger() + +def mkstring(): + n = int(min(abs(normalvariate(40, 20)), abs(normalvariate(30, 10)))) + return ''.join([choice(string.ascii_letters) for i in range(0, n)]) + +values = [mkconstant, mknum, mknum, mknum, mkstring] + +def mkvalue(): + return choice(values)() + +def mkarray(n, t, threshold): + a = [] + t2 = t + random() + if (t > threshold): + for i in range(0, 2 * n): + a.append(mkvalue()) + else: + #print "mkarray(%s, %s, %s)" % (n, t, threshold) + for i in range(0, n / 5): + a.append(mkcontainer(t2, threshold)) + return a + +def mkobject(n, t, threshold): + d = {} + t2 = t + random() + if (t > threshold): + for i in range(0, n): + k = mkstring() + v = mkvalue() + d[k] = v + else: + #print "mkobject(%s, %s, %s)" % (n, t, threshold) + for i in range(0, n / 10): + k = mkstring() + v = mkcontainer(t2, threshold) + d[k] = v + return d + +containers = [mkarray, mkobject, mkobject] + +def mkcontainer(t, threshold): + n = int(abs(normalvariate(10, 30))) + return choice(containers)(n, t, threshold) + +if __name__ == "__main__": + args = sys.argv[1:] + try: + weight = float(args[0]) + path = args[1] + print "generating random JSON with weight %s into %s" % (weight, path) + f = open(path, 'w') + c = mkcontainer(0.0, weight) + f.write(json.dumps(c)) + f.close() + except: + print "usage: %s WEIGHT (0.0 < w < ~4.0) FILE" % sys.argv[0] diff --git a/scalaplugin/src/test/resource/jawn/randjson2.py b/scalaplugin/src/test/resource/jawn/randjson2.py new file mode 100644 index 00000000..eb6b9a3a --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/randjson2.py @@ -0,0 +1,53 @@ +import json +import os +from random import * +import string +import sys + +constants = [True, False, None] + +def mkconstant(): + return choice(constants) + +def mkinteger(): + return randint(-1e3, 1e3) * (10 ** normalvariate(0, 4)) + randint(-1e3, 1e3) + +def mkdouble(): + return random() * (10 ** normalvariate(0, 30)) + +def mknum(): + if randint(0, 1): + return mkdouble() + else: + return mkinteger() + +def mkstring(): + n = int(min(abs(normalvariate(40, 20)), abs(normalvariate(30, 10)))) + return ''.join([choice(string.ascii_letters) for i in range(0, n)]) + +values = [mkconstant, mknum, mknum, mknum, mkstring] + +def mkvalue(): + return choice(values)() + +if __name__ == "__main__": + args = sys.argv[1:] + try: + num = int(args[0]) + path = args[1] + print "writing json (%d rows) into %s" % (num, path) + f = open(path, 'w') + f.write("[") + for i in range(0, num): + if i > 0: f.write(", ") + c = {"foo": mkstring(), + "bar": mknum(), + "qux": mkvalue(), + "duh": {"a": mknum(), "b": mknum(), "c": mknum()}, + "xyz": {"yy": mkstring(), "zz": mkvalue()}, + "abc": [mkvalue() for i in range(0, 4)]} + f.write(json.dumps(c)) + f.write("]") + f.close() + except Exception, e: + print "usage: %s NUM PATH" % sys.argv[0] diff --git a/scalaplugin/src/test/resource/jawn/support/argonaut/src/main/scala/Parser.scala b/scalaplugin/src/test/resource/jawn/support/argonaut/src/main/scala/Parser.scala new file mode 100644 index 00000000..0c57e4d7 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/support/argonaut/src/main/scala/Parser.scala @@ -0,0 +1,45 @@ +package jawn +package support.argonaut + +import scala.collection.mutable +import argonaut._ + +object Parser extends SupportParser[Json] { + implicit val facade: Facade[Json] = + new Facade[Json] { + def jnull() = Json.jNull + def jfalse() = Json.jFalse + def jtrue() = Json.jTrue + + def jnum(s: CharSequence, decIndex: Int, expIndex: Int) = + Json.jNumber(JsonNumber.unsafeDecimal(s.toString)) + def jstring(s: CharSequence) = Json.jString(s.toString) + + def singleContext() = new FContext[Json] { + var value: Json = null + def add(s: CharSequence) { value = jstring(s) } + def add(v: Json) { value = v } + def finish: Json = value + def isObj: Boolean = false + } + + def arrayContext() = new FContext[Json] { + val vs = mutable.ListBuffer.empty[Json] + def add(s: CharSequence) { vs += jstring(s) } + def add(v: Json) { vs += v } + def finish: Json = Json.jArray(vs.toList) + def isObj: Boolean = false + } + + def objectContext() = new FContext[Json] { + var key: String = null + var vs = JsonObject.empty + def add(s: CharSequence): Unit = + if (key == null) { key = s.toString } else { vs = vs + (key, jstring(s)); key = null } + def add(v: Json): Unit = + { vs = vs + (key, v); key = null } + def finish = Json.jObject(vs) + def isObj = true + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/support/argonaut/src/test/scala/ParserSpec.scala b/scalaplugin/src/test/resource/jawn/support/argonaut/src/test/scala/ParserSpec.scala new file mode 100644 index 00000000..bb6a8566 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/support/argonaut/src/test/scala/ParserSpec.scala @@ -0,0 +1,41 @@ +package jawn +package support.argonaut + +import argonaut._ +import Argonaut._ +import org.scalacheck.Arbitrary +import org.scalacheck.Arbitrary.arbitrary +import org.scalatest.prop.Checkers +import org.scalatest.{Matchers, FlatSpec} +import scala.util.Try + +object ParserSpec { + case class Example(a: Int, b: Long, c: Double) + + val exampleCodecJson: CodecJson[Example] = + casecodec3(Example.apply, Example.unapply)("a", "b", "c") + + implicit val exampleCaseClassArbitrary: Arbitrary[Example] = Arbitrary( + for { + a <- arbitrary[Int] + b <- arbitrary[Long] + c <- arbitrary[Double] + } yield Example(a, b, c) + ) +} + +class ParserSpec extends FlatSpec with Matchers with Checkers { + import ParserSpec._ + import jawn.support.argonaut.Parser.facade + + "The Argonaut support Parser" should "correctly marshal case classes with Long values" in { + check { (e: Example) => + val jsonString: String = exampleCodecJson.encode(e).nospaces + val json: Try[Json] = jawn.Parser.parseFromString(jsonString) + exampleCodecJson.decodeJson(json.get).toOption match { + case None => fail() + case Some(example) => example == e + } + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/support/json4s/src/main/scala/Parser.scala b/scalaplugin/src/test/resource/jawn/support/json4s/src/main/scala/Parser.scala new file mode 100644 index 00000000..e552621c --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/support/json4s/src/main/scala/Parser.scala @@ -0,0 +1,59 @@ +package jawn +package support.json4s + +import scala.collection.mutable +import org.json4s.JsonAST._ + +object Parser extends Parser(false, false) + +class Parser(useBigDecimalForDouble: Boolean, useBigIntForLong: Boolean) extends SupportParser[JValue] { + + implicit val facade: Facade[JValue] = + new Facade[JValue] { + def jnull() = JNull + def jfalse() = JBool(false) + def jtrue() = JBool(true) + + def jnum(s: CharSequence, decIndex: Int, expIndex: Int) = + if (decIndex == -1 && expIndex == -1) { + if (useBigIntForLong) JInt(BigInt(s.toString)) + else JLong(util.parseLongUnsafe(s)) + } else { + if (useBigDecimalForDouble) JDecimal(BigDecimal(s.toString)) + else JDouble(s.toString.toDouble) + } + + def jstring(s: CharSequence) = JString(s.toString) + + def singleContext() = + new FContext[JValue] { + var value: JValue = null + def add(s: CharSequence) { value = jstring(s) } + def add(v: JValue) { value = v } + def finish: JValue = value + def isObj: Boolean = false + } + + def arrayContext() = + new FContext[JValue] { + val vs = mutable.ListBuffer.empty[JValue] + def add(s: CharSequence) { vs += jstring(s) } + def add(v: JValue) { vs += v } + def finish: JValue = JArray(vs.toList) + def isObj: Boolean = false + } + + def objectContext() = + new FContext[JValue] { + var key: String = null + val vs = mutable.ListBuffer.empty[JField] + def add(s: CharSequence): Unit = + if (key == null) key = s.toString + else { vs += JField(key, jstring(s)); key = null } + def add(v: JValue): Unit = + { vs += JField(key, v); key = null } + def finish: JValue = JObject(vs.toList) + def isObj: Boolean = true + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/support/play/src/main/scala/Parser.scala b/scalaplugin/src/test/resource/jawn/support/play/src/main/scala/Parser.scala new file mode 100644 index 00000000..1bca206a --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/support/play/src/main/scala/Parser.scala @@ -0,0 +1,20 @@ +package jawn +package support.play + +import play.api.libs.json._ + +object Parser extends SupportParser[JsValue] { + + implicit val facade: Facade[JsValue] = + new SimpleFacade[JsValue] { + def jnull() = JsNull + def jfalse() = JsBoolean(false) + def jtrue() = JsBoolean(true) + + def jnum(s: CharSequence, decIndex: Int, expIndex: Int) = JsNumber(BigDecimal(s.toString)) + def jstring(s: CharSequence) = JsString(s.toString) + + def jarray(vs: List[JsValue]) = JsArray(vs) + def jobject(vs: Map[String, JsValue]) = JsObject(vs) + } +} diff --git a/scalaplugin/src/test/resource/jawn/support/rojoma-v3/src/main/scala/Parser.scala b/scalaplugin/src/test/resource/jawn/support/rojoma-v3/src/main/scala/Parser.scala new file mode 100644 index 00000000..c031e71f --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/support/rojoma-v3/src/main/scala/Parser.scala @@ -0,0 +1,18 @@ +package jawn +package support.rojoma.v3 + +import scala.collection.mutable +import com.rojoma.json.v3.ast._ + +object Parser extends SupportParser[JValue] { + implicit val facade: Facade[JValue] = + new MutableFacade[JValue] { + def jnull() = JNull + def jfalse() = JBoolean.canonicalFalse + def jtrue() = JBoolean.canonicalTrue + def jnum(s: CharSequence, decIndex: Int, expIndex: Int) = JNumber.unsafeFromString(s.toString) + def jstring(s: CharSequence) = JString(s.toString) + def jarray(vs: mutable.ArrayBuffer[JValue]) = JArray(vs) + def jobject(vs: mutable.Map[String, JValue]) = JObject(vs) + } +} diff --git a/scalaplugin/src/test/resource/jawn/support/rojoma/src/main/scala/Parser.scala b/scalaplugin/src/test/resource/jawn/support/rojoma/src/main/scala/Parser.scala new file mode 100644 index 00000000..c0725ea3 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/support/rojoma/src/main/scala/Parser.scala @@ -0,0 +1,18 @@ +package jawn +package support.rojoma + +import scala.collection.mutable +import com.rojoma.json.ast._ + +object Parser extends SupportParser[JValue] { + implicit val facade: Facade[JValue] = + new MutableFacade[JValue] { + def jnull() = JNull + def jfalse() = JBoolean.canonicalFalse + def jtrue() = JBoolean.canonicalTrue + def jnum(s: CharSequence, decIndex: Int, expIndex: Int) = JNumber(BigDecimal(s.toString)) + def jstring(s: CharSequence) = JString(s.toString) + def jarray(vs: mutable.ArrayBuffer[JValue]) = JArray(vs) + def jobject(vs: mutable.Map[String, JValue]) = JObject(vs) + } +} diff --git a/scalaplugin/src/test/resource/jawn/support/spray/src/main/scala/Parser.scala b/scalaplugin/src/test/resource/jawn/support/spray/src/main/scala/Parser.scala new file mode 100644 index 00000000..2e589666 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/support/spray/src/main/scala/Parser.scala @@ -0,0 +1,17 @@ +package jawn +package support.spray + +import spray.json._ + +object Parser extends SupportParser[JsValue] { + implicit val facade: Facade[JsValue] = + new SimpleFacade[JsValue] { + def jnull() = JsNull + def jfalse() = JsFalse + def jtrue() = JsTrue + def jnum(s: CharSequence, decIndex: Int, expIndex: Int) = JsNumber(s.toString) + def jstring(s: CharSequence) = JsString(s.toString) + def jarray(vs: List[JsValue]) = JsArray(vs: _*) + def jobject(vs: Map[String, JsValue]) = JsObject(vs) + } +} diff --git a/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/InvalidLong.scala b/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/InvalidLong.scala new file mode 100644 index 00000000..adffb979 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/InvalidLong.scala @@ -0,0 +1,7 @@ +package jawn.util + +class InvalidLong(s: String) extends NumberFormatException(s"For input string '$s'") + +object InvalidLong { + def apply(s: String): InvalidLong = new InvalidLong(s) +} diff --git a/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/Slice.scala b/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/Slice.scala new file mode 100644 index 00000000..93a8159b --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/Slice.scala @@ -0,0 +1,95 @@ +package jawn.util + +/** + * Character sequence representing a lazily-calculated substring. + * + * This class has three constructors: + * + * - Slice(s) wraps a string, ensuring that future operations + * (e.g. subSequence) will construct slices instead of strings. + * + * - Slice(s, start, limit) is the default, and ensures that: + * + * 1. start >= 0 + * 2. limit >= start + * 3. limit <= s.length + * + * - Slice.unsafe(s, start, limit) is for situations where the above + * bounds-checking has already occurred. Only use this if you are + * absolutely sure your arguments satisfy the above invariants. + * + * Slice's subSequence returns another slice. This means that when + * wrapping a very large string, garbage collection on the underlying + * string will not occur until all slices are freed. + * + * Slice's universal equality is only defined with regard to other + * slices. This means comparing a Slice with other CharSequence values + * (including String) will always return false. + * + * Slices are serializable. However! They use the default Java + * serialization layout, which is not that efficient, and could be a + * disaster in cases where a large shared string might be serialized + * many times in different slices. + */ +@SerialVersionUID(1L) +final class Slice private[jawn] (s: String, start: Int, limit: Int) extends CharSequence with Serializable { + + final val length: Int = + limit - start + + def charAt(i: Int): Char = + if (i < 0 || length <= i) throw new StringIndexOutOfBoundsException(s"index out of range: $i") + else s.charAt(start + i) + + def subSequence(i: Int, j: Int): Slice = + Slice(s, start + i, start + j) + + override def toString: String = + s.substring(start, limit) + + override def equals(that: Any): Boolean = + that match { + case t: AnyRef if this eq t => + true + case slice: Slice => + if (length != slice.length) return false + var i: Int = 0 + while (i < length) { + if (charAt(i) != slice.charAt(i)) return false + i += 1 + } + true + case _ => + false + } + + override def hashCode: Int = { + var hash: Int = 0x90decade + var i: Int = start + while (i < limit) { + hash = s.charAt(i) + (hash * 103696301) // prime + i += 1 + } + hash + } +} + +object Slice { + + val Empty: Slice = Slice("", 0, 0) + + def empty: Slice = Empty + + def apply(s: String): Slice = + new Slice(s, 0, s.length) + + def apply(s: String, start: Int, limit: Int): Slice = + if (start < 0 || limit < start || s.length < limit) { + throw new IndexOutOfBoundsException(s"invalid slice: start=$start, limit=$limit, length=${s.length}") + } else { + new Slice(s, start, limit) + } + + def unsafe(s: String, start: Int, limit: Int): Slice = + new Slice(s, start, limit) +} diff --git a/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/package.scala b/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/package.scala new file mode 100644 index 00000000..08f7ae3e --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/util/src/main/scala/jawn/util/package.scala @@ -0,0 +1,96 @@ +package jawn + +package object util { + + /** + * Parse the given character sequence as a single Long value (64-bit + * signed integer) in decimal (base-10). + * + * Other than "0", leading zeros are not allowed, nor are leading + * plusses. At most one leading minus is allowed. The value "-0" is + * allowed, and is interpreted as 0. + * + * Stated more precisely, accepted values: + * + * - conform to the pattern: -?(0|([1-9][0-9]*)) + * - are within [-9223372036854775808, 9223372036854775807] + * + * This method will throw an `InvalidLong` exception on invalid + * input. + */ + def parseLong(cs: CharSequence): Long = { + + // we store the inverse of the positive sum, to ensure we don't + // incorrectly overflow on Long.MinValue. for positive numbers + // this inverse sum will be inverted before being returned. + var inverseSum: Long = 0L + var inverseSign: Long = -1L + var i: Int = 0 + + if (cs.charAt(0) == '-') { + inverseSign = 1L + i = 1 + } + + val len = cs.length + val size = len - i + if (i >= len) throw InvalidLong(cs.toString) + if (size > 19) throw InvalidLong(cs.toString) + if (cs.charAt(i) == '0' && size > 1) throw InvalidLong(cs.toString) + + while (i < len) { + val digit = cs.charAt(i).toInt - 48 + if (digit < 0 || 9 < digit) throw InvalidLong(cs.toString) + inverseSum = inverseSum * 10L - digit + i += 1 + } + + // detect and throw on overflow + if (size == 19 && (inverseSum >= 0 || (inverseSum == Long.MinValue && inverseSign < 0))) { + throw InvalidLong(cs.toString) + } + + inverseSum * inverseSign + } + + /** + * Parse the given character sequence as a single Long value (64-bit + * signed integer) in decimal (base-10). + * + * For valid inputs, this method produces the same values as + * `parseLong`. However, by avoiding input validation it is up to + * 50% faster. + * + * For inputs which `parseLong` throws an error on, + * `parseLongUnsafe` may (or may not) throw an error, or return a + * bogus value. This method makes no guarantees about how it handles + * invalid input. + * + * This method should only be used on sequences which have already + * been parsed (e.g. by a Jawn parser). When in doubt, use + * `parseLong(cs)`, which is still significantly faster than + * `java.lang.Long.parseLong(cs.toString)`. + */ + def parseLongUnsafe(cs: CharSequence): Long = { + + // we store the inverse of the positive sum, to ensure we don't + // incorrectly overflow on Long.MinValue. for positive numbers + // this inverse sum will be inverted before being returned. + var inverseSum: Long = 0L + var inverseSign: Long = -1L + var i: Int = 0 + + if (cs.charAt(0) == '-') { + inverseSign = 1L + i = 1 + } + + val len = cs.length + while (i < len) { + inverseSum = inverseSum * 10L - (cs.charAt(i).toInt - 48) + i += 1 + } + + inverseSum * inverseSign + } +} diff --git a/scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/ParseLongCheck.scala b/scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/ParseLongCheck.scala new file mode 100644 index 00000000..69c4a0e2 --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/ParseLongCheck.scala @@ -0,0 +1,72 @@ +package jawn +package util + +import org.scalatest._ +import prop._ +import org.scalacheck._ + +import scala.util._ + +class ParseLongCheck extends PropSpec with Matchers with PropertyChecks { + + case class UniformLong(value: Long) + + object UniformLong { + implicit val arbitraryUniformLong: Arbitrary[UniformLong] = + Arbitrary(Gen.choose(Long.MinValue, Long.MaxValue).map(UniformLong(_))) + } + + property("both parsers accept on valid input") { + forAll { (n0: UniformLong, prefix: String, suffix: String) => + val n = n0.value + val payload = n.toString + val s = prefix + payload + suffix + val i = prefix.length + val cs = s.subSequence(i, payload.length + i) + cs.toString shouldBe payload + parseLong(cs) shouldBe n + parseLongUnsafe(cs) shouldBe n + } + + forAll { (s: String) => + Try(parseLong(s)) match { + case Success(n) => parseLongUnsafe(s) shouldBe n + case Failure(_) => succeed + } + } + } + + property("safe parser fails on invalid input") { + forAll { (n: Long, m: Long, suffix: String) => + val s1 = n.toString + suffix + Try(parseLong(s1)) match { + case Success(n) => n shouldBe s1.toLong + case Failure(_) => Try(s1.toLong).isFailure + } + + val s2 = n.toString + (m & 0x7fffffffffffffffL).toString + Try(parseLong(s2)) match { + case Success(n) => n shouldBe s2.toLong + case Failure(_) => Try(s2.toLong).isFailure + } + } + + Try(parseLong("9223372036854775807")) shouldBe Try(Long.MaxValue) + Try(parseLong("-9223372036854775808")) shouldBe Try(Long.MinValue) + Try(parseLong("-0")) shouldBe Try(0L) + + assert(Try(parseLong("")).isFailure) + assert(Try(parseLong("+0")).isFailure) + assert(Try(parseLong("00")).isFailure) + assert(Try(parseLong("01")).isFailure) + assert(Try(parseLong("+1")).isFailure) + assert(Try(parseLong("-")).isFailure) + assert(Try(parseLong("--1")).isFailure) + assert(Try(parseLong("9223372036854775808")).isFailure) + assert(Try(parseLong("-9223372036854775809")).isFailure) + } + + // NOTE: parseLongUnsafe is not guaranteed to crash, or do anything + // predictable, on invalid input, so we don't test this direction. + // Its "unsafe" suffix is there for a reason. +} diff --git a/scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/SliceCheck.scala b/scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/SliceCheck.scala new file mode 100644 index 00000000..b56e105e --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/util/src/test/scala/jawn/util/SliceCheck.scala @@ -0,0 +1,131 @@ +package jawn +package util + +import org.scalatest._ +import prop._ +import org.scalacheck._ + +import Arbitrary.arbitrary + +import scala.util._ + +class SliceCheck extends PropSpec with Matchers with PropertyChecks { + + val genSlice: Gen[Slice] = { + val g = arbitrary[String] + def c(start: Int, end: Int): Gen[Int] = + if (end <= start) Gen.const(start) + else Gen.choose(start, end) + Gen.oneOf( + g.map(Slice(_)), + for { s <- g; n = s.length; i <- c(0, n) } yield Slice(s, i, n), + for { s <- g; n = s.length; j <- c(0, n) } yield Slice(s, 0, j), + for { s <- g; n = s.length; i <- c(0, n); j <- c(i, n) } yield Slice(s, i, j)) + } + + implicit val arbitrarySlice: Arbitrary[Slice] = + Arbitrary(genSlice) + + def tryEqual[A](got0: => A, expected0: => A): Unit = { + val got = Try(got0) + val expected = Try(expected0) + got match { + case Success(_) => got shouldBe expected + case Failure(_) => assert(expected.isFailure) + } + } + + property("Slice(s, i, j) ~ s.substring(i, j)") { + forAll { (s: String, i: Int, j: Int) => + tryEqual( + Slice(s, i, j).toString, + s.substring(i, j)) + } + } + + property("Slice(s, i, j).charAt(k) ~ s.substring(i, j).charAt(k)") { + forAll { (s: String, i: Int, j: Int, k: Int) => + tryEqual( + Slice(s, i, j).charAt(k), + s.substring(i, j).charAt(k)) + } + } + + property("slice.length >= 0") { + forAll { (cs: Slice) => + cs.length should be >= 0 + } + } + + property("slice.charAt(i) ~ slice.toString.charAt(i)") { + forAll { (cs: Slice, i: Int) => + tryEqual( + cs.charAt(i), + cs.toString.charAt(i)) + } + } + + property("Slice(s, i, j).subSequence(k, l) ~ s.substring(i, j).substring(k, l)") { + forAll { (s: String, i: Int, j: Int, k: Int, l: Int) => + tryEqual( + Slice(s, i, j).subSequence(k, l).toString, + s.substring(i, j).substring(k, l)) + } + } + + property("Slice(s) ~ Slice(s, 0, s.length)") { + forAll { (s: String) => + tryEqual( + Slice(s).toString, + Slice(s, 0, s.length).toString) + } + } + + property("Slice(s, i, j) => Slice.unsafe(s, i, j)") { + forAll { (s: String, i: Int, j: Int) => + Try(Slice(s, i, j).toString) match { + case Success(r) => r shouldBe Slice.unsafe(s, i, j).toString + case Failure(_) => succeed + } + } + } + + property("x == x") { + forAll { (x: Slice) => x shouldBe x } + } + + property("(x == y) = (x.toString == y.toString)") { + forAll { (x: Slice, y: Slice) => + (x == y) shouldBe (x.toString == y.toString) + } + } + + property("(x == y) -> (x.## == y.##)") { + forAll { (x: Slice, y: Slice) => + if (x == y) x.## shouldBe y.## + else (x.## == y.##) shouldBe false + } + } + + property("x == Slice(x.toString)") { + forAll { (x: Slice) => + Slice(x.toString) shouldBe x + } + } + + property("slice is serializable") { + import java.io._ + + forAll { (x: Slice) => + val baos = new ByteArrayOutputStream() + val oos = new ObjectOutputStream(baos) + oos.writeObject(x) + oos.close() + val bytes = baos.toByteArray + val bais = new ByteArrayInputStream(bytes) + val ois = new ObjectInputStream(bais) + Try(ois.readObject()) shouldBe Try(x) + ois.close() + } + } +} diff --git a/scalaplugin/src/test/resource/jawn/version.sbt b/scalaplugin/src/test/resource/jawn/version.sbt new file mode 100644 index 00000000..1b9f6b1b --- /dev/null +++ b/scalaplugin/src/test/resource/jawn/version.sbt @@ -0,0 +1 @@ +version in ThisBuild := "0.11.1-SNAPSHOT" diff --git a/scalaplugin/src/test/scala/mill/scalaplugin/JawnTests.scala b/scalaplugin/src/test/scala/mill/scalaplugin/JawnTests.scala new file mode 100644 index 00000000..b48fd853 --- /dev/null +++ b/scalaplugin/src/test/scala/mill/scalaplugin/JawnTests.scala @@ -0,0 +1,91 @@ +package mill.scalaplugin + +import ammonite.ops.ImplicitWd._ +import ammonite.ops._ +import mill.Module +import mill.define.{Cross, Task} +import mill.discover.Discovered +import mill.eval.Result +import utest._ +import mill.util.JsonFormatters._ + +object JawnBuild{ + val Jawn = Cross("2.10.6", "2.11.11", "2.12.3").map(new Jawn(_)) + class Jawn(crossVersion: String) extends Module{ + trait JawnModule extends SbtScalaModule{ outer => + def scalaVersion = crossVersion + override def scalacOptions = Seq( + "-deprecation", + "-optimize", + "-unchecked" + ) + def testProjectDeps: Seq[TestScalaModule] = Nil + object test extends this.Tests{ + override def projectDeps = super.projectDeps ++ testProjectDeps + override def ivyDeps = Seq( + Dep("org.scalatest", "scalatest", "3.0.3"), + Dep("org.scalacheck", "scalacheck", "1.13.5") + ) + def testFramework = "org.scalatest.tools.Framework" + } + } + object Parser extends JawnModule{ + def basePath = JawnTests.srcPath/"parser" + } + object Util extends JawnModule{ + override def projectDeps = Seq(Parser) + override def testProjectDeps = Seq(Parser.test) + def basePath = JawnTests.srcPath/"util" + } + object Ast extends JawnModule{ + override def projectDeps = Seq(Parser, Util) + override def testProjectDeps = Seq(Parser.test, Util.test) + def basePath = JawnTests.srcPath/"ast" + } + class Support(name: String, ivyDeps0: Dep*) extends JawnModule{ + override def projectDeps = Seq[ScalaModule](Parser) + def basePath = JawnTests.srcPath/"support"/"argonaut" + override def ivyDeps = ivyDeps0 + } + object Argonaut extends Support("argonaut", Dep("io.argonaut", "argonaut", "6.2")) + object Json4s extends Support("json4s", Dep("org.json4s", "json4s-ast", "3.5.2")) + + object Play extends Support("play"){ + override def ivyDeps = mill.T{ + scalaBinaryVersion() match{ + case "2.10" => Seq(Dep("com.typesafe.play", "play-json", "2.4.11")) + case "2.11" => Seq(Dep("com.typesafe.play", "play-json", "2.5.15")) + case _ => Seq(Dep("com.typesafe.play", "play-json", "2.6.0")) + } + } + } + + object Rojoma extends Support("rojoma", Dep("com.rojoma", "rojoma-json", "2.4.3")) + object RojomaV3 extends Support("rojoma-v3", Dep("com.rojoma", "rojoma-json-v3", "3.7.2")) + object Spray extends Support("spray", Dep("io.spray", "spray-json", "1.3.3")) + } + +} +object JawnTests extends TestSuite{ + val workspacePath = pwd / 'target / 'workspace / "jawn" + val srcPath = pwd / 'scalaplugin / 'src / 'test / 'resource / "jawn" + val tests = Tests{ + rm(workspacePath) + mkdir(workspacePath/up) + cp(srcPath, workspacePath) + val mapping = Discovered.mapping(JawnBuild) + def eval[T](t: Task[T]) = TestEvaluator.eval(mapping, workspacePath)(t) + + 'test - { + def compileOutput = workspacePath / 'jawn / "2.12.3" / 'Parser / 'compile + def testCompileOutput = workspacePath / 'jawn / "2.12.3" / 'Parser / 'test / 'compile + assert(!exists(compileOutput), !exists(testCompileOutput)) + val Right(_) = eval(JawnBuild.Jawn("2.12.3").Parser.test.test()) + assert( + ls.rec(compileOutput).exists(_.last == "AsyncParser.class"), + ls.rec(testCompileOutput).exists(_.last == "CharBuilderSpec.class") + ) + } + + } +} -- cgit v1.2.3