Extracted from purescript-argonaut

.gitignore

@@ -0,0 +1,8 @@
+/.*
+!/.gitignore
+!/.travis.yml
+bower_components/
+node_modules/
+output/
+dist/
+npm-debug.log

.travis.yml

@@ -0,0 +1,13 @@
+language: node_js
+node_js:
+  - 0.10
+env:
+  - TAG=v0.7.0
+install:
+  - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz
+  - sudo tar zxvf $HOME/purescript.tar.gz -C /usr/local/bin purescript/psc{,i,-docs,-bundle} --strip-components=1
+  - sudo chmod a+x /usr/local/bin/psc{,i,-docs,-bundle}
+  - npm install bower gulp -g
+  - npm install && bower install
+script:
+  - gulp test

README.md

@@ -1 +1,17 @@
+[![Build Status](https://travis-ci.org/purescript-contrib/purescript-argonaut-codecs.svg?branch=master)](https://travis-ci.org/purescript-contrib/purescript-argonaut-codecs)
+
 # purescript-argonaut-codecs
+
+`EncodeJson` and `DecodeJson` classes and instances for __purescript-argonaut__. Also useful combinators for encoding ando decoding stuff.
+
+## Installation
+
+```shell
+bower install purescript-argonaut-codecs
+```
+
+## Documentaion
+
+- [Data.Argonaut.Encode](docs/Data/Argonaut/Encode.md)
+- [Data.Argonaut.Decode](docs/Data/Argonaut/Decode.md)
+- [Data.Argonaut.Combinators](docs/Data/Argonaut/Combinators.md)

bower.json

@@ -0,0 +1,38 @@
+{
+  "name": "purescript-argonaut-codecs",
+  "homepage": "https://github.com/purescript-contrib/purescript-argonaut-codecs",
+  "authors": [
+    "Maxim Zimaliev <[email protected]>",
+    "Hardy Jones <>",
+    "John A. De Goes <[email protected]>"
+  ],
+  "description": "Codecs for purescript argonaut",
+  "keywords": [
+    "purescript",
+    "json",
+    "argonaut",
+    "encode",
+    "decode",
+    "codec",
+    "combinators"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "purescript-argonaut-core": "~0.1.0",
+    "purescript-maybe": "~0.3.2",
+    "purescript-either": "~0.2.0",
+    "purescript-arrays": "~0.4.0",
+    "purescript-strings": "~0.5.3",
+    "purescript-lists": "~0.7.0",
+    "purescript-maps": "~0.4.0",
+    "purescript-foldable-traversable": "~0.4.0",
+    "purescript-unfoldable": "~0.4.0",
+    "purescript-tuples": "~0.4.0",
+    "purescript-control": "~0.3.0"
+  },
+  "devDependencies": {
+    "purescript-eff": "~0.1.0",
+    "purescript-console": "~0.1.0",
+    "purescript-strongcheck": "~0.10.0"
+  }
+}

docs/Data/Argonaut/Combinators.md

@@ -0,0 +1,35 @@
+## Module Data.Argonaut.Combinators
+
+#### `(:=)`
+
+``` purescript
+(:=) :: forall a. (EncodeJson a) => String -> a -> JAssoc
+```
+
+_non-associative / precedence 7_
+
+#### `(~>)`
+
+``` purescript
+(~>) :: forall a. (EncodeJson a) => JAssoc -> a -> Json
+```
+
+_right-associative / precedence 6_
+
+#### `(?>>=)`
+
+``` purescript
+(?>>=) :: forall a b. Maybe a -> String -> Either String a
+```
+
+_left-associative / precedence 1_
+
+#### `(.?)`
+
+``` purescript
+(.?) :: forall a. (DecodeJson a) => JObject -> String -> Either String a
+```
+
+_non-associative / precedence 7_
+
+

docs/Data/Argonaut/Decode.md

@@ -0,0 +1,34 @@
+## Module Data.Argonaut.Decode
+
+#### `DecodeJson`
+
+``` purescript
+class DecodeJson a where
+  decodeJson :: Json -> Either String a
+```
+
+##### Instances
+``` purescript
+instance decodeJsonMaybe :: (DecodeJson a) => DecodeJson (Maybe a)
+instance decodeJsonTuple :: (DecodeJson a, DecodeJson b) => DecodeJson (Tuple a b)
+instance decodeJsonEither :: (DecodeJson a, DecodeJson b) => DecodeJson (Either a b)
+instance decodeJsonNull :: DecodeJson Unit
+instance decodeJsonBoolean :: DecodeJson Boolean
+instance decodeJsonNumber :: DecodeJson Number
+instance decodeJsonInt :: DecodeJson Int
+instance decodeJsonString :: DecodeJson String
+instance decodeJsonJson :: DecodeJson Json
+instance decodeJsonChar :: DecodeJson Char
+instance decodeStrMap :: (DecodeJson a) => DecodeJson (StrMap a)
+instance decodeArray :: (DecodeJson a) => DecodeJson (Array a)
+instance decodeList :: (DecodeJson a) => DecodeJson (List a)
+instance decodeMap :: (Ord a, DecodeJson a, DecodeJson b) => DecodeJson (Map a b)
+```
+
+#### `decodeMaybe`
+
+``` purescript
+decodeMaybe :: forall a. (DecodeJson a) => Json -> Maybe a
+```
+
+

docs/Data/Argonaut/Encode.md

@@ -0,0 +1,28 @@
+## Module Data.Argonaut.Encode
+
+#### `EncodeJson`
+
+``` purescript
+class EncodeJson a where
+  encodeJson :: a -> Json
+```
+
+##### Instances
+``` purescript
+instance encodeJsonMaybe :: (EncodeJson a) => EncodeJson (Maybe a)
+instance encodeJsonTuple :: (EncodeJson a, EncodeJson b) => EncodeJson (Tuple a b)
+instance encodeJsonEither :: (EncodeJson a, EncodeJson b) => EncodeJson (Either a b)
+instance encodeJsonUnit :: EncodeJson Unit
+instance encodeJsonJBoolean :: EncodeJson Boolean
+instance encodeJsonJNumber :: EncodeJson Number
+instance encodeJsonInt :: EncodeJson Int
+instance encodeJsonJString :: EncodeJson String
+instance encodeJsonJson :: EncodeJson Json
+instance encodeJsonChar :: EncodeJson Char
+instance encodeJsonArray :: (EncodeJson a) => EncodeJson (Array a)
+instance encodeJsonList :: (EncodeJson a) => EncodeJson (List a)
+instance encodeStrMap :: (EncodeJson a) => EncodeJson (StrMap a)
+instance encodeMap :: (Ord a, EncodeJson a, EncodeJson b) => EncodeJson (Map a b)
+```
+
+

gulpfile.js

@@ -0,0 +1,70 @@
+'use strict'
+
+
+var gulp        = require('gulp')
+  , purescript  = require('gulp-purescript')
+  , run         = require('gulp-run')
+  , runSequence = require('run-sequence')
+  ;
+
+function sequence() {
+    var args = [].slice.apply(arguments);
+    return function() {
+        runSequence.apply(null, args);
+    };
+}
+
+var sources = [
+    'src/**/*.purs',
+    'bower_components/purescript-*/src/**/*.purs'
+];
+
+var foreigns = [
+    'src/**/*.js',
+    'bower_components/purescript-*/src/**/*.js'
+];
+
+var testSources = [
+    'test/**/*.purs'
+];
+
+var testForeigns = [
+    'test/**/*.js'
+];
+
+gulp.task('docs', function() {
+    return purescript.pscDocs({
+        src: sources,
+        docgen: {
+            "Data.Argonaut.Encode": "docs/Data/Argonaut/Encode.md",
+            "Data.Argonaut.Decode": "docs/Data/Argonaut/Decode.md",
+            "Data.Argonaut.Combinators": "docs/Data/Argonaut/Combinators.md"
+        }
+    });
+});
+
+
+gulp.task('make', function() {
+    return purescript.psc({
+        src: sources,
+        ffi: foreigns
+    });
+});
+
+gulp.task('test-make', function() {
+    return purescript.psc({
+        src: sources.concat(testSources),
+        ffi: foreigns.concat(testForeigns)
+    });
+});
+
+gulp.task('test', ['test-make'], function() {
+    return purescript.pscBundle({
+        src: "output/**/*.js",
+        main: "Test.Main",
+        output: "dist/test.js"
+    }).pipe(run('node dist/test.js'));
+});
+
+
+gulp.task("default", sequence("make", "docs"));

package.json

@@ -0,0 +1,11 @@
+{
+  "name": "purescript-argonaut-codecs",
+  "description": "Codecs for purescript-argonaut library",
+  "license": "MIT",
+  "dependencies": {
+    "gulp": "^3.9.0",
+    "gulp-purescript": "^0.5.0",
+    "gulp-run": "^1.6.8",
+    "run-sequence": "^1.1.1"
+  }
+}

src/Data/Argonaut/Combinators.purs

@@ -0,0 +1,43 @@
+module Data.Argonaut.Combinators
+  ( (:=)
+  , (~>)
+  , (?>>=)
+  , (.?)
+  ) where
+
+import Prelude
+
+import Data.Argonaut.Core
+  ( foldJsonObject
+  , fromObject
+  , jsonSingletonObject
+  , Json()
+  , JAssoc()
+  , JObject()
+  )
+import Data.Argonaut.Encode (encodeJson, EncodeJson)
+import Data.Argonaut.Decode (DecodeJson, decodeJson)
+import Data.Either (Either(..))
+import Data.Maybe (Maybe(..), maybe)
+import Data.Tuple (Tuple(..))
+
+import qualified Data.StrMap as M
+
+infix 7 :=
+infix 7 .?
+infixr 6 ~>
+infixl 1 ?>>=
+
+(:=) :: forall a. (EncodeJson a) => String -> a -> JAssoc
+(:=) k v = Tuple k $ encodeJson v
+
+(~>) :: forall a. (EncodeJson a) => JAssoc -> a -> Json
+(~>) (Tuple k v) a = foldJsonObject (jsonSingletonObject k v) (M.insert k v >>> fromObject) (encodeJson a)
+
+(?>>=) :: forall a b. Maybe a -> String -> Either String a
+(?>>=) (Just x) _   = Right x
+(?>>=) _        str = Left $ "Couldn't decode " ++ str
+
+-- obj .? "foo"
+(.?) :: forall a. (DecodeJson a) => JObject -> String -> Either String a
+(.?) o s = maybe (Left $ "Expected field " ++ show s) decodeJson (M.lookup s o)