Merge pull request #7 from jdegoes/master

add arb instances for string & alpha num string, migrate to gulp, add sized generators

Author: paf31

.gitignore

@@ -5,3 +5,4 @@
 /bower_components/
 /tmp/
 /node_modules/
+/test/

Gruntfile.js

@@ -4,6 +4,9 @@
 
 ### Types
 
+    newtype AlphaNumString where
+      AlphaNumString :: String -> AlphaNumString
+
     type QC a = forall eff. Eff (err :: Exception, random :: Random, trace :: Trace | eff) a
 
     data Result where
@@ -25,6 +28,8 @@
 
 ### Type Class Instances
 
+    instance arbAlphaNumString :: Arbitrary AlphaNumString
+
     instance arbArray :: (Arbitrary a) => Arbitrary [a]
 
     instance arbBoolean :: Arbitrary Boolean
@@ -33,6 +38,10 @@
 
     instance arbNumber :: Arbitrary Number
 
+    instance arbString :: Arbitrary String
+
+    instance coarbAlphaNumString :: CoArbitrary AlphaNumString
+
     instance coarbArray :: (CoArbitrary a) => CoArbitrary [a]
 
     instance coarbBoolean :: CoArbitrary Boolean
@@ -41,6 +50,8 @@
 
     instance coarbNumber :: CoArbitrary Number
 
+    instance coarbString :: CoArbitrary String
+
     instance showResult :: Show Result
 
     instance testableBoolean :: Testable Boolean
@@ -60,52 +71,5 @@
 
     quickCheckPure :: forall prop. (Testable prop) => Number -> Number -> prop -> [Result]
 
-    repeatable :: forall a b. (a -> Gen b) -> Gen (a -> b)
-
-
-## Module Test.QuickCheck.LCG
-
-### Types
-
-    data Gen a where
-      Gen :: LCG -> { newSeed :: LCG, value :: a } -> Gen a
-
-    type LCG  = Number
-
-
-### Type Class Instances
-
-    instance applicativeGen :: Applicative Gen
-
-    instance applyGen :: Apply Gen
-
-    instance bindGen :: Bind Gen
-
-    instance functorGen :: Functor Gen
-
-    instance monadGen :: Monad Gen
-
-
-### Values
-
-    evalGen :: forall a. Gen a -> LCG -> a
-
-    float32ToInt32 :: Number -> Number
-
-    lcgC :: Number
-
-    lcgM :: Number
-
-    lcgN :: Number
-
-    lcgNext :: Number -> Number
-
-    lcgStep :: Gen Number
-
-    perturbGen :: forall a. Number -> Gen a -> Gen a
-
-    randomSeed :: forall eff. Eff (random :: Random | eff) Number
 
-    runGen :: forall a. Gen a -> LCG -> { newSeed :: LCG, value :: a }
 
-    uniform :: Gen Number

README.md

@@ -1,5 +1,6 @@
 {
   "name": "purescript-quickcheck",
+  "version": "0.0.2",
   "license": "MIT",
   "ignore": [
     "**/.*",
@@ -14,6 +15,9 @@
   ],
   "dependencies": {
     "purescript-random": "*",
-    "purescript-exceptions": "0.2.0"
+    "purescript-exceptions": "0.2.0",
+    "purescript-arrays": "*",
+    "purescript-strings": "*",
+    "purescript-math": "*"
   }
 }

bower.json

@@ -0,0 +1,93 @@
+'use strict'
+
+var gulp        = require('gulp')
+  , purescript  = require('gulp-purescript')
+  , run         = require('gulp-run')
+  , runSequence = require('run-sequence')
+  ;
+
+var paths = {
+    src: 'src/**/*.purs',
+    bowerSrc: [
+      'bower_components/purescript-*/src/**/*.purs',
+      'bower_components/purescript-*/src/**/*.purs.hs'
+    ],
+    dest: '',
+    docs: {
+        'Test.QuickCheck': {
+            dest: 'README.md',
+            src: 'src/Test/QuickCheck.purs'
+        },
+        'Test.QuickCheck.*': {
+            dest: 'src/Test/QuickCheck/README.md',
+            src: 'src/Test/QuickCheck/*.purs'
+        }
+    },
+    test: 'examples/*.purs'
+};
+
+var options = {
+    test: {
+        main: 'PreludeTests',
+        output: 'test/test.js'
+    }
+};
+
+function compile (compiler, src, opts) {
+    var psc = compiler(opts);
+    psc.on('error', function(e) {
+        console.error(e.message);
+        psc.end();
+    });
+    return gulp.src(src.concat(paths.bowerSrc))
+        .pipe(psc)
+        .pipe(gulp.dest(paths.dest));
+};
+
+function docs (target) {
+    return function() {
+        var docgen = purescript.docgen();
+        docgen.on('error', function(e) {
+            console.error(e.message);
+            docgen.end();
+        });
+        return gulp.src(paths.docs[target].src)
+            .pipe(docgen)
+            .pipe(gulp.dest(paths.docs[target].dest));
+    }
+}
+
+function sequence () {
+    var args = [].slice.apply(arguments);
+    return function() {
+        runSequence.apply(null, args);
+    }
+}
+
+gulp.task('browser', function() {
+    return compile(purescript.psc, [paths.src].concat(paths.bowerSrc), {})
+});
+
+gulp.task('make', function() {
+    return compile(purescript.pscMake, [paths.src].concat(paths.bowerSrc), {})
+});
+
+gulp.task('test', function() {
+    return compile(purescript.psc, [paths.src, paths.test].concat(paths.bowerSrc), options.test)
+        .pipe(run('node').exec());
+});
+
+gulp.task('docs-Test.QuickCheck', docs('Test.QuickCheck'));
+gulp.task('docs-Test.QuickCheck.*', docs('Test.QuickCheck.*'));
+
+gulp.task('docs', ['docs-Test.QuickCheck', 'docs-Test.QuickCheck.*']);
+
+gulp.task('watch-browser', function() {
+    gulp.watch(paths.src, sequence('browser', 'docs'));
+});
+
+gulp.task('watch-make', function() {
+    gulp.watch(paths.src, sequence('make', 'docs'));
+});
+
+gulp.task('default', sequence('make', 'docs'));

gulpfile.js

@@ -1,8 +1,13 @@
 {
-  "private": true,
-  "dependencies": {
-    "grunt": "~0.4.4",
-    "grunt-purescript": "~0.5.1",
-    "grunt-contrib-clean": "~0.5.0"
+  "name":       "purescript-quickcheck",
+  "version":    "0.0.2",
+  "license":    "MIT",
+  "repository": "[email protected]:purescript-contrib/purescript-quickcheck.git",
+
+  "devDependencies": {
+    "gulp":             "^3.8.8",
+    "gulp-purescript":  "0.0.10",
+    "gulp-run":         "^1.6.4",
+    "run-sequence":     "^0.3.6"
   }
-}
+}

package.json

@@ -1,12 +1,19 @@
 module Test.QuickCheck where
 
 import Debug.Trace
+import Control.Bind
 import Control.Monad.Eff
 import Control.Monad.Eff.Random
 import Control.Monad.Eff.Exception
+import Data.Array
+import Math
+
+import qualified Data.String as S
 
 import Test.QuickCheck.LCG
 
+newtype AlphaNumString = AlphaNumString String
+
 class Arbitrary t where
   arbitrary :: Gen t
 
@@ -35,15 +42,32 @@ instance arbBoolean :: Arbitrary Boolean where
     return $ (n * 2) < 1
 
 instance coarbBoolean :: CoArbitrary Boolean where
-  coarbitrary true (Gen f) = Gen $ \l -> f (l + 1)
-  coarbitrary false (Gen f) = Gen $ \l -> f (l + 2)
+  coarbitrary true = perturbGen 1
+  coarbitrary false = perturbGen 2
+
+instance arbString :: Arbitrary String where
+  arbitrary = do
+    arrNum <- arbitrary
+    return $ (S.joinWith "") $ S.fromCharCode <<< ((*) 65535) <$> arrNum
+
+instance coarbString :: CoArbitrary String where
+  coarbitrary s = coarbitrary $ (S.charCodeAt 0 <$> S.split "" s)
+
+instance arbAlphaNumString :: Arbitrary AlphaNumString where
+  arbitrary = do
+    arrNum <- arbitrary
+    return $ AlphaNumString <<< (S.joinWith "") $ lookup <$> arrNum where
+      chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+      lookup x = S.charAt index chars where
+        index = round $ x * (S.length chars - 1)
+
+instance coarbAlphaNumString :: CoArbitrary AlphaNumString where
+  coarbitrary (AlphaNumString s) = coarbitrary s
 
 instance arbFunction :: (CoArbitrary a, Arbitrary b) => Arbitrary (a -> b) where
   arbitrary = repeatable (\a -> coarbitrary a arbitrary)
 
-repeatable :: forall a b. (a -> Gen b) -> Gen (a -> b)
-repeatable f = Gen $ \l -> { value: \a -> (runGen (f a) l).value, newSeed: l }
-
 instance coarbFunction :: (Arbitrary a, CoArbitrary b) => CoArbitrary (a -> b) where
   coarbitrary f gen = do
     xs <- arbitrary
@@ -80,19 +104,20 @@ instance testableFunction :: (Arbitrary t, Testable prop) => Testable (t -> prop
     test (f t)
 
 quickCheckPure :: forall prop. (Testable prop) => Number -> Number -> prop -> [Result]
-quickCheckPure seed n prop = evalGen (go n) seed
-  where
-  go n | n <= 0 = return []
-  go n = do
-    result <- test prop
-    rest <- go (n - 1)
-    return $ result : rest
+quickCheckPure s = quickCheckPure' {newSeed: s, size: 10} where
+  quickCheckPure' st n prop = evalGen (go n) st 
+    where
+    go n | n <= 0 = return []
+    go n = do
+      result <- test prop
+      rest <- go (n - 1)
+      return $ result : rest
 
 type QC a = forall eff. Eff (trace :: Trace, random :: Random, err :: Exception | eff) a
 
 quickCheck' :: forall prop. (Testable prop) => Number -> prop -> QC Unit
 quickCheck' n prop = do
-  seed <- randomSeed
+  seed <- random
   let results = quickCheckPure seed n prop
   let successes = countSuccesses results
   trace $ show successes ++ "/" ++ show n ++ " test(s) passed."