jteeuwissen/json-logic-haskell

JsonLogic library for Haskell

JsonLogic

JsonLogic library for Haskell

Packages

This repository holds the packages for:

• jsonlogic
• jsonlogic-aeson

Example

See the example project for extra context. Or the example from the core project.

Run tests

Run all package tests:

cabal test all

Build

build all packages:

cabal build all

Documentation

To build all documentation run:

cabal haddock all

json-logic-haskell's Issues

Implement `all`

Add a doctest testing stage

replace getOperations with getSubEvaluator

implement `between`

Show instance for Json type

Write a show instance so it is easily readable from the terminal.

Rename the operations file to to operation

Implement `filter`

Implement `merge`

Convert json string to our own Json type

Probably using aeson FromJSON instance.
Not sure what the alternative approach was.

Implement `missing` and `missing_some`

Implement `map`

Test toJson in aeson project

Tests exist, but not everything is tested yet.

Implement `in`

Define generators for our JSON type

For automated testing it would be useful to have generators

Probably best to generate haskell code equivalent next to it so we know what result to expect
F.e generate these two in the same generator. We take the Haskell as expected and json as result.
JSON: JsonObject $ Map.singleton "+" (JsonArray [JsonNumber 1, JsonNumber 2])
Haskell: ((+) 1 2)

Also keep in mind that some need numeric json as parameters whilst others need booleans.
So generatorNumericJson
generatorBoolJson
generatorStringJson

are some of the generators to expose for testing purposes

Define generators for invalidJson + write tests for them

Also invalid JSON needs to get tested. Now we only test for succes result.
Generators still need to get defined for invalid JSON. but should be doable using already written generators

Instead of evaluating parameters let the function evaluate stuff itself.

Implement `cat`

Generator tests for var

Test var using generators

Replace Either err val with Except err val

Implement number indexing using var.

See this issue for more information.

Write generators for JsonData

Write generators for the data section
also one that is able to generate a json containing a specific section

Hide JL a and only exposes instantiated version (like IO Either and Either)

Make `==` work for value comparison, not just boolean.

Allow the access of the variable stack from within a function, not just the current context.

Use a single row for operation type instead of a separate definition for each operation

(+) :: Operation
(+) = ("+", evaluateMath (Prelude.+))

(-) :: Operation
(-) = ("-", evaluateMath (Prelude.-))

(+), (-) :: Operation
(+) = ("+", evaluateMath (Prelude.+))
(-) = ("-", evaluateMath (Prelude.-))

Implement `if`

Remove the docker test image after running

So they do not pile up after running.
Also remove the image if this does not remove the cache layers.

Use `concurrency` to cancel running tasks when new issues are commited on a merge.

see https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#concurrency

Pretty print JSON

Pretty print the JSON so it is a readable format.
Maybe use the aeson for this since it is already implemented there

Use generators in tests

Generators are written in #23
Use them in randomized tests, the expected result is also given in the generator

implement `%`

Show instance for Json type

Write a show instance so it is easily readable from the terminal.

Use custom state to allow for the modification of variables but not of functions.

Use a random Id to run the docker files instead of using `--quiet`

So we can have the docker build logs without image clashes.

Implement `none`

Implement `max` and `min`

Implement `substr`

Expose all operations through `JsonLogic.Operation` instead of individually.

Lint for unused imports.

Add `FromJson` to the aeson library

Automated document generation

Use haddock to generate documentation in the pipeline.
Could be pushed to several endpoints including Wiki.
Determine what make the most sense and is supported.

Implement context

This time trying only to implement this feature

Add a `var2` function to use indexes instead of string for objects.

{"var":[["propname",2,"prop.name"],"backup"]}

Implement `reduce`

Eval not evaluating other json values, just objects. should be all.

Properly evaluate var with arrays and objects.

Implement `some`

Create getFuncs, getVars and putVar

Implement proper equality comparisons

As LooseEquals in https://github.com/gregsdennis/json-everything/blob/master/JsonLogic/JsonElementExtensions.cs

Use error handling with errors containing function name, parameters and error description instead on Nothing.