Update task names to reflect purs commands

Author: garyb

README.md

@@ -21,8 +21,8 @@ var gulp = require('gulp');
 
 var purescript = require('gulp-purescript');
 
-gulp.task('psc', function(){
-  return purescript.psc({
+gulp.task('make', function(){
+  return purescript.compile({
     src: 'src/*.purs'
   });
 });
@@ -36,9 +36,9 @@ Refer to the PureScript [compiler usage](https://github.com/purescript/purescrip
 
 Options can be passed to the Haskell runtime system for `purs` by passing a `--purs-rts-flags` argument to `gulp`. Any values that follow this flag will be passed through to the runtime. There is no need to include `+RTS`/`-RTS` options as these are inserted automatically. See [the GHC documentation](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/runtime-control.html#rts-opts-cmdline) for information on the available RTS options.
 
-### `purescript.psc(options)`
+### `purescript.compile(options)`
 
-Invokes the `psc` command. The following options are supported.
+Invokes the `purs compile` command. The following options are supported.
 
 ###### `src` (String or String Array)
 
@@ -72,13 +72,13 @@ Toggles `--no-prefix` that does not include the comment header.
 
 Toggles `--json-errors` that prints errors to stderr as JSON.
 
-### `purescript.pscBundle(options)`
+### `purescript.bundle(options)`
 
-Invokes the `purs compile` command. The following options are supported.
+Invokes the `purs bundle` command. The following options are supported.
 
 ###### `src` (String or String Array)
 
-The `psc`-produced JavaScript source files to bundle. Glob syntax is supported.
+The `purs compile`-produced JavaScript source files to bundle. Glob syntax is supported.
 
 ###### `output` (String)
 
@@ -100,7 +100,7 @@ Sets `--namespace=<string>` that specifies the namespace that PureScript modules
 
 Toggles `--source-maps` that generates source maps.
 
-### `purescript.pscDocs(options)`
+### `purescript.docs(options)`
 
 Invokes the `purs docs` command. The following options are supported.
 
@@ -143,15 +143,15 @@ var sources = [
 ];
 
 gulp.task("make", function () {
-  return purescript.psc({ src: sources });
+  return purescript.compile({ src: sources });
 });
 
 gulp.task("bundle", ["make"], function () {
-  return purescript.pscBundle({ src: "output/**/*.js", output: "dist/bundle.js" });
+  return purescript.bundle({ src: "output/**/*.js", output: "dist/bundle.js" });
 });
 
 gulp.task("docs", function () {
-  return purescript.pscDocs({
+  return purescript.docs({
       src: sources,
       docgen: {
         "Name.Of.Module1": "docs/Name/Of/Module1.md",
@@ -166,7 +166,7 @@ gulp.task("dotpsci", function () {
 });
 
 gulp.task("test", ["make"], function() {
-  return purescript.pscBundle({ src: "output/**/*.js", main: "Test.Main" })
+  return purescript.bundle({ src: "output/**/*.js", main: "Test.Main" })
     .pipe(run("node"));
 });
 

index.js

@@ -2,26 +2,26 @@
 
 var gulpPurescript = require('./output/GulpPurescript.Plugin');
 
-function psc(options) {
-  return gulpPurescript.psc(options)();
+function compile(options) {
+  return gulpPurescript.compile(options)();
 }
 
-function pscBundle(options) {
-  return gulpPurescript.pscBundle(options)();
+function bundle(options) {
+  return gulpPurescript.bundle(options)();
 }
 
-function pscDocs(options) {
-  return gulpPurescript.pscDocs(options)();
+function docs(options) {
+  return gulpPurescript.docs(options)();
 }
 
 function psci(options) {
   return gulpPurescript.psci(options)();
 }
 
-module.exports.psc = psc;
+module.exports.compile = compile;
 
-module.exports.pscBundle = pscBundle;
+module.exports.bundle = bundle;
 
-module.exports.pscDocs = pscDocs;
+module.exports.docs = docs;
 
 module.exports.psci = psci;

package.json

@@ -17,9 +17,9 @@
     "output"
   ],
   "scripts": {
-    "psc": "purs compile 'src/**/*.purs' 'bower_components/purescript-*/src/**/*.purs'",
-    "test": "npm run psc && (node test/test.js | tap-spec)",
-    "prepublish": "rimraf output && npm run psc"
+    "build": "purs compile 'src/**/*.purs' 'bower_components/purescript-*/src/**/*.purs'",
+    "test": "npm run build && (node test/test.js | tap-spec)",
+    "prepublish": "rimraf output && npm run build"
   },
   "keywords": [
     "gulpplugin",

src/GulpPurescript/Options.purs

@@ -1,8 +1,8 @@
 module GulpPurescript.Options
   ( Psci(..)
-  , pscOptions
-  , pscBundleOptions
-  , pscDocsOptions
+  , compileOptions
+  , bundleOptions
+  , docsOptions
   , readPsci
   ) where
 
@@ -106,8 +106,8 @@ docgenOpt = "docgen"
 docgenKey :: String
 docgenKey = docgenOpt
 
-newtype Psc
-  = Psc { src :: Either String (Array String)
+newtype Compile
+  = Compile { src :: Either String (Array String)
         , output :: Maybe String
         , verboseErrors :: Maybe Boolean
         , comments :: Maybe Boolean
@@ -117,17 +117,17 @@ newtype Psc
         , jsonErrors :: Maybe Boolean
         }
 
-newtype PscBundle
-  = PscBundle { src :: Either String (Array String)
+newtype Bundle
+  = Bundle { src :: Either String (Array String)
               , output :: Maybe String
               , "module" :: Maybe (Either String (Array String))
               , main :: Maybe (Either Boolean String)
               , namespace :: Maybe String
               , sourceMaps :: Maybe Boolean
               }
 
-newtype PscDocs
-  = PscDocs { src :: Either String (Array String)
+newtype Docs
+  = Docs { src :: Either String (Array String)
             , format :: Maybe Format
             , docgen :: Maybe Docgen
             }
@@ -141,8 +141,8 @@ newtype PathArray = PathArray (Array String)
 
 data Format = Markdown | ETags | CTags
 
-readPsc :: Foreign -> F Psc
-readPsc obj = do
+readCompile :: Foreign -> F Compile
+readCompile obj = do
   src <- readSources =<< readProp srcKey obj
   output <- readPropNU readString outputKey obj
   verboseErrors <- readPropNU readBoolean verboseErrorsKey obj
@@ -151,24 +151,24 @@ readPsc obj = do
   dumpCoreFn <- readPropNU readBoolean dumpCoreFnKey obj
   noPrefix <- readPropNU readBoolean noPrefixKey obj
   jsonErrors <- readPropNU readBoolean jsonErrorsKey obj
-  pure $ Psc { src, output, verboseErrors, comments, sourceMaps, dumpCoreFn, noPrefix, jsonErrors }
+  pure $ Compile { src, output, verboseErrors, comments, sourceMaps, dumpCoreFn, noPrefix, jsonErrors }
 
-readPscBundle :: Foreign -> F PscBundle
-readPscBundle obj = do
+readBundle :: Foreign -> F Bundle
+readBundle obj = do
   src <- readSources =<< readProp srcKey obj
   output <- readPropNU readString outputKey obj
   mod <- readPropNU readSources moduleKey obj
   main <- readPropNU (readEither readBoolean readString) mainKey obj
   namespace <- readPropNU readString namespaceKey obj
   sourceMaps <- readPropNU readBoolean sourceMapsKey obj
-  pure $ PscBundle { src, output, "module": mod, main, namespace, sourceMaps }
+  pure $ Bundle { src, output, "module": mod, main, namespace, sourceMaps }
 
-readPscDocs :: Foreign -> F PscDocs
-readPscDocs obj = do
+readDocs :: Foreign -> F Docs
+readDocs obj = do
   src <- readSources =<< readProp srcKey obj
   format <- readPropNU readFormat formatKey obj
   docgen <- readPropNU readDocgen docgenOpt obj
-  pure $ PscDocs { src, format, docgen }
+  pure $ Docs { src, format, docgen }
 
 readPsci :: Foreign -> F Psci
 readPsci obj = Psci <$> { src: _ } <$> (readSources =<< readProp srcKey obj)
@@ -232,14 +232,14 @@ parseDocgen (Docgen obj) =
     modules <- keys obj'
     for modules \m -> (\f -> m <> ":" <> f) <$> (readString =<< readProp m obj')
 
-pscOptions :: Foreign -> F (Array String)
-pscOptions opts = fold <$> parsed
+compileOptions :: Foreign -> F (Array String)
+compileOptions opts = fold <$> parsed
   where
-  parsed :: F Psc
-  parsed = readPsc opts
+  parsed :: F Compile
+  parsed = readCompile opts
 
-  fold :: Psc -> Array String
-  fold (Psc a) = either pure id a.src <>
+  fold :: Compile -> Array String
+  fold (Compile a) = either pure id a.src <>
                  opt outputOpt a.output <>
                  opt verboseErrorsOpt a.verboseErrors <>
                  opt commentsOpt a.comments <>
@@ -248,37 +248,34 @@ pscOptions opts = fold <$> parsed
                  opt noPrefixOpt a.noPrefix <>
                  opt jsonErrorsOpt a.jsonErrors
 
-pscBundleOptions :: Foreign -> F (Array String)
-pscBundleOptions opts = fold <$> parsed
+bundleOptions :: Foreign -> F (Array String)
+bundleOptions opts = fold <$> parsed
   where
-  parsed :: F PscBundle
-  parsed = readPscBundle opts
+  parsed :: F Bundle
+  parsed = readBundle opts
 
-  fold :: PscBundle -> Array String
-  fold (PscBundle a) = either pure id a.src <>
+  fold :: Bundle -> Array String
+  fold (Bundle a) = either pure id a.src <>
                        opt outputOpt a.output <>
                        opt moduleOpt a."module" <>
                        opt mainOpt a.main <>
                        opt namespaceOpt a.namespace <>
                        opt sourceMapsOpt a.sourceMaps
 
-pscDocsOptions :: Foreign -> F (Array String)
-pscDocsOptions opts = fold <$> parsed
+docsOptions :: Foreign -> F (Array String)
+docsOptions opts = fold <$> parsed
   where
-  parsed :: F PscDocs
-  parsed = readPscDocs opts
+  parsed :: F Docs
+  parsed = readDocs opts
 
-  fold :: PscDocs -> Array String
-  fold (PscDocs a) = either pure id a.src <>
+  fold :: Docs -> Array String
+  fold (Docs a) = either pure id a.src <>
                      opt formatOpt a.format <>
                      opt docgenOpt a.docgen
 
 readEither :: forall left right. (Foreign -> F left) -> (Foreign -> F right) -> Foreign -> F (Either left right)
 readEither readL readR a = (Left <$> readL a) <|> (Right <$> readR a)
 
-readEitherNU :: forall left right. (Foreign -> F left) -> (Foreign -> F right) -> Foreign -> F (Maybe (Either left right))
-readEitherNU readL readR = traverse (readEither readL readR) <=< readNullOrUndefined
-
 readPropNU :: forall a. (Foreign -> F a) -> String -> Foreign -> F (Maybe a)
 readPropNU f k = traverse f <=< readNullOrUndefined <=< readProp k
 

src/GulpPurescript/Plugin.purs

@@ -2,9 +2,9 @@ module GulpPurescript.Plugin
   ( Effects
   , Errorback
   , Callback
-  , psc
-  , pscBundle
-  , pscDocs
+  , compile
+  , bundle
+  , docs
   , psci
   ) where
 
@@ -31,7 +31,7 @@ import GulpPurescript.ChildProcess (ChildProcess, spawn)
 import GulpPurescript.Glob (Glob, globAll)
 import GulpPurescript.GulpUtil (File, mkFile, mkPluginError)
 import GulpPurescript.Logalot (Logalot, info)
-import GulpPurescript.Options (Psci(..), pscOptions, pscBundleOptions, pscDocsOptions, readPsci)
+import GulpPurescript.Options (Psci(..), compileOptions, bundleOptions, docsOptions, readPsci)
 import GulpPurescript.OS (OS, Platform(Win32), platform)
 import GulpPurescript.Path (relative)
 import GulpPurescript.ResolveBin (ResolveBin, resolveBin)
@@ -117,24 +117,24 @@ execute cmd args = do
   result <- spawn cmd' args'
   pure result
 
-psc :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream Unit)
-psc opts = mkReadableStreamFromAff $ do
+compile :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream Unit)
+compile opts = mkReadableStreamFromAff $ do
   output <- handleRead
                    (execute compileCommand <<< (_ <> rtsOpts))
-                   (pscOptions opts)
+                   (compileOptions opts)
   if null output
      then pure unit
      else liftEff $ info $ compileCommand <> "\n" <> output
 
-pscBundle :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream File)
-pscBundle opts = mkReadableStreamFromAff (handleRead run (pscBundleOptions opts))
+bundle :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream File)
+bundle opts = mkReadableStreamFromAff (handleRead run (bundleOptions opts))
   where
     run :: Array String -> Aff (Effects eff) File
     run args = mkFile "." <$> mkBufferFromString
                           <$> execute bundleCommand args
 
-pscDocs :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream File)
-pscDocs opts = mkReadableStreamFromAff (handleRead run (pscDocsOptions opts))
+docs :: forall eff. Foreign -> Eff (Effects eff) (ReadableStream File)
+docs opts = mkReadableStreamFromAff (handleRead run (docsOptions opts))
   where
     run :: Array String -> Aff (Effects eff) File
     run args = mkFile "." <$> mkBufferFromString