wallaby 7.0.0.beta1 → 7.0.0

data/vendor/assets/javascripts/codemirror/5.49.2/mode/haskell/haskell.js

@@ -1,268 +0,0 @@
-// CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: https://codemirror.net/LICENSE
-
-(function(mod) {
-  if (typeof exports == "object" && typeof module == "object") // CommonJS
-    mod(require("../../lib/codemirror"));
-  else if (typeof define == "function" && define.amd) // AMD
-    define(["../../lib/codemirror"], mod);
-  else // Plain browser env
-    mod(CodeMirror);
-})(function(CodeMirror) {
-"use strict";
-
-CodeMirror.defineMode("haskell", function(_config, modeConfig) {
-
-  function switchState(source, setState, f) {
-    setState(f);
-    return f(source, setState);
-  }
-
-  // These should all be Unicode extended, as per the Haskell 2010 report
-  var smallRE = /[a-z_]/;
-  var largeRE = /[A-Z]/;
-  var digitRE = /\d/;
-  var hexitRE = /[0-9A-Fa-f]/;
-  var octitRE = /[0-7]/;
-  var idRE = /[a-z_A-Z0-9'\xa1-\uffff]/;
-  var symbolRE = /[-!#$%&*+.\/<=>?@\\^|~:]/;
-  var specialRE = /[(),;[\]`{}]/;
-  var whiteCharRE = /[ \t\v\f]/; // newlines are handled in tokenizer
-
-  function normal(source, setState) {
-    if (source.eatWhile(whiteCharRE)) {
-      return null;
-    }
-
-    var ch = source.next();
-    if (specialRE.test(ch)) {
-      if (ch == '{' && source.eat('-')) {
-        var t = "comment";
-        if (source.eat('#')) {
-          t = "meta";
-        }
-        return switchState(source, setState, ncomment(t, 1));
-      }
-      return null;
-    }
-
-    if (ch == '\'') {
-      if (source.eat('\\')) {
-        source.next();  // should handle other escapes here
-      }
-      else {
-        source.next();
-      }
-      if (source.eat('\'')) {
-        return "string";
-      }
-      return "string error";
-    }
-
-    if (ch == '"') {
-      return switchState(source, setState, stringLiteral);
-    }
-
-    if (largeRE.test(ch)) {
-      source.eatWhile(idRE);
-      if (source.eat('.')) {
-        return "qualifier";
-      }
-      return "variable-2";
-    }
-
-    if (smallRE.test(ch)) {
-      source.eatWhile(idRE);
-      return "variable";
-    }
-
-    if (digitRE.test(ch)) {
-      if (ch == '0') {
-        if (source.eat(/[xX]/)) {
-          source.eatWhile(hexitRE); // should require at least 1
-          return "integer";
-        }
-        if (source.eat(/[oO]/)) {
-          source.eatWhile(octitRE); // should require at least 1
-          return "number";
-        }
-      }
-      source.eatWhile(digitRE);
-      var t = "number";
-      if (source.match(/^\.\d+/)) {
-        t = "number";
-      }
-      if (source.eat(/[eE]/)) {
-        t = "number";
-        source.eat(/[-+]/);
-        source.eatWhile(digitRE); // should require at least 1
-      }
-      return t;
-    }
-
-    if (ch == "." && source.eat("."))
-      return "keyword";
-
-    if (symbolRE.test(ch)) {
-      if (ch == '-' && source.eat(/-/)) {
-        source.eatWhile(/-/);
-        if (!source.eat(symbolRE)) {
-          source.skipToEnd();
-          return "comment";
-        }
-      }
-      var t = "variable";
-      if (ch == ':') {
-        t = "variable-2";
-      }
-      source.eatWhile(symbolRE);
-      return t;
-    }
-
-    return "error";
-  }
-
-  function ncomment(type, nest) {
-    if (nest == 0) {
-      return normal;
-    }
-    return function(source, setState) {
-      var currNest = nest;
-      while (!source.eol()) {
-        var ch = source.next();
-        if (ch == '{' && source.eat('-')) {
-          ++currNest;
-        }
-        else if (ch == '-' && source.eat('}')) {
-          --currNest;
-          if (currNest == 0) {
-            setState(normal);
-            return type;
-          }
-        }
-      }
-      setState(ncomment(type, currNest));
-      return type;
-    };
-  }
-
-  function stringLiteral(source, setState) {
-    while (!source.eol()) {
-      var ch = source.next();
-      if (ch == '"') {
-        setState(normal);
-        return "string";
-      }
-      if (ch == '\\') {
-        if (source.eol() || source.eat(whiteCharRE)) {
-          setState(stringGap);
-          return "string";
-        }
-        if (source.eat('&')) {
-        }
-        else {
-          source.next(); // should handle other escapes here
-        }
-      }
-    }
-    setState(normal);
-    return "string error";
-  }
-
-  function stringGap(source, setState) {
-    if (source.eat('\\')) {
-      return switchState(source, setState, stringLiteral);
-    }
-    source.next();
-    setState(normal);
-    return "error";
-  }
-
-
-  var wellKnownWords = (function() {
-    var wkw = {};
-    function setType(t) {
-      return function () {
-        for (var i = 0; i < arguments.length; i++)
-          wkw[arguments[i]] = t;
-      };
-    }
-
-    setType("keyword")(
-      "case", "class", "data", "default", "deriving", "do", "else", "foreign",
-      "if", "import", "in", "infix", "infixl", "infixr", "instance", "let",
-      "module", "newtype", "of", "then", "type", "where", "_");
-
-    setType("keyword")(
-      "\.\.", ":", "::", "=", "\\", "<-", "->", "@", "~", "=>");
-
-    setType("builtin")(
-      "!!", "$!", "$", "&&", "+", "++", "-", ".", "/", "/=", "<", "<*", "<=",
-      "<$>", "<*>", "=<<", "==", ">", ">=", ">>", ">>=", "^", "^^", "||", "*",
-      "*>", "**");
-
-    setType("builtin")(
-      "Applicative", "Bool", "Bounded", "Char", "Double", "EQ", "Either", "Enum",
-      "Eq", "False", "FilePath", "Float", "Floating", "Fractional", "Functor",
-      "GT", "IO", "IOError", "Int", "Integer", "Integral", "Just", "LT", "Left",
-      "Maybe", "Monad", "Nothing", "Num", "Ord", "Ordering", "Rational", "Read",
-      "ReadS", "Real", "RealFloat", "RealFrac", "Right", "Show", "ShowS",
-      "String", "True");
-
-    setType("builtin")(
-      "abs", "acos", "acosh", "all", "and", "any", "appendFile", "asTypeOf",
-      "asin", "asinh", "atan", "atan2", "atanh", "break", "catch", "ceiling",
-      "compare", "concat", "concatMap", "const", "cos", "cosh", "curry",
-      "cycle", "decodeFloat", "div", "divMod", "drop", "dropWhile", "either",
-      "elem", "encodeFloat", "enumFrom", "enumFromThen", "enumFromThenTo",
-      "enumFromTo", "error", "even", "exp", "exponent", "fail", "filter",
-      "flip", "floatDigits", "floatRadix", "floatRange", "floor", "fmap",
-      "foldl", "foldl1", "foldr", "foldr1", "fromEnum", "fromInteger",
-      "fromIntegral", "fromRational", "fst", "gcd", "getChar", "getContents",
-      "getLine", "head", "id", "init", "interact", "ioError", "isDenormalized",
-      "isIEEE", "isInfinite", "isNaN", "isNegativeZero", "iterate", "last",
-      "lcm", "length", "lex", "lines", "log", "logBase", "lookup", "map",
-      "mapM", "mapM_", "max", "maxBound", "maximum", "maybe", "min", "minBound",
-      "minimum", "mod", "negate", "not", "notElem", "null", "odd", "or",
-      "otherwise", "pi", "pred", "print", "product", "properFraction", "pure",
-      "putChar", "putStr", "putStrLn", "quot", "quotRem", "read", "readFile",
-      "readIO", "readList", "readLn", "readParen", "reads", "readsPrec",
-      "realToFrac", "recip", "rem", "repeat", "replicate", "return", "reverse",
-      "round", "scaleFloat", "scanl", "scanl1", "scanr", "scanr1", "seq",
-      "sequence", "sequence_", "show", "showChar", "showList", "showParen",
-      "showString", "shows", "showsPrec", "significand", "signum", "sin",
-      "sinh", "snd", "span", "splitAt", "sqrt", "subtract", "succ", "sum",
-      "tail", "take", "takeWhile", "tan", "tanh", "toEnum", "toInteger",
-      "toRational", "truncate", "uncurry", "undefined", "unlines", "until",
-      "unwords", "unzip", "unzip3", "userError", "words", "writeFile", "zip",
-      "zip3", "zipWith", "zipWith3");
-
-    var override = modeConfig.overrideKeywords;
-    if (override) for (var word in override) if (override.hasOwnProperty(word))
-      wkw[word] = override[word];
-
-    return wkw;
-  })();
-
-
-
-  return {
-    startState: function ()  { return { f: normal }; },
-    copyState:  function (s) { return { f: s.f }; },
-
-    token: function(stream, state) {
-      var t = state.f(stream, function(s) { state.f = s; });
-      var w = stream.current();
-      return wellKnownWords.hasOwnProperty(w) ? wellKnownWords[w] : t;
-    },
-
-    blockCommentStart: "{-",
-    blockCommentEnd: "-}",
-    lineComment: "--"
-  };
-
-});
-
-CodeMirror.defineMIME("text/x-haskell", "haskell");
-
-});

data/vendor/assets/javascripts/codemirror/5.49.2/mode/haskell/index.html

@@ -1,73 +0,0 @@
-<!doctype html>
-
-<title>CodeMirror: Haskell mode</title>
-<meta charset="utf-8"/>
-<link rel=stylesheet href="../../doc/docs.css">
-
-<link rel="stylesheet" href="../../lib/codemirror.css">
-<link rel="stylesheet" href="../../theme/elegant.css">
-<script src="../../lib/codemirror.js"></script>
-<script src="../../addon/edit/matchbrackets.js"></script>
-<script src="haskell.js"></script>
-<style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
-<div id=nav>
-  <a href="https://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png" alt=""></a>
-
-  <ul>
-    <li><a href="../../index.html">Home</a>
-    <li><a href="../../doc/manual.html">Manual</a>
-    <li><a href="https://github.com/codemirror/codemirror">Code</a>
-  </ul>
-  <ul>
-    <li><a href="../index.html">Language modes</a>
-    <li><a class=active href="#">Haskell</a>
-  </ul>
-</div>
-
-<article>
-<h2>Haskell mode</h2>
-<form><textarea id="code" name="code">
-module UniquePerms (
-    uniquePerms
-    )
-where
-
--- | Find all unique permutations of a list where there might be duplicates.
-uniquePerms :: (Eq a) => [a] -> [[a]]
-uniquePerms = permBag . makeBag
-
--- | An unordered collection where duplicate values are allowed,
--- but represented with a single value and a count.
-type Bag a = [(a, Int)]
-
-makeBag :: (Eq a) => [a] -> Bag a
-makeBag [] = []
-makeBag (a:as) = mix a $ makeBag as
-  where
-    mix a []                        = [(a,1)]
-    mix a (bn@(b,n):bs) | a == b    = (b,n+1):bs
-                        | otherwise = bn : mix a bs
-
-permBag :: Bag a -> [[a]]
-permBag [] = [[]]
-permBag bs = concatMap (\(f,cs) -> map (f:) $ permBag cs) . oneOfEach $ bs
-  where
-    oneOfEach [] = []
-    oneOfEach (an@(a,n):bs) =
-        let bs' = if n == 1 then bs else (a,n-1):bs
-        in (a,bs') : mapSnd (an:) (oneOfEach bs)
-    
-    apSnd f (a,b) = (a, f b)
-    mapSnd = map . apSnd
-</textarea></form>
-
-    <script>
-      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
-        lineNumbers: true,
-        matchBrackets: true,
-        theme: "elegant"
-      });
-    </script>
-
-    <p><strong>MIME types defined:</strong> <code>text/x-haskell</code>.</p>
-  </article>

data/vendor/assets/javascripts/codemirror/5.49.2/mode/haskell-literate/haskell-literate.js

@@ -1,43 +0,0 @@
-// CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: https://codemirror.net/LICENSE
-
-(function (mod) {
-  if (typeof exports == "object" && typeof module == "object") // CommonJS
-    mod(require("../../lib/codemirror"), require("../haskell/haskell"))
-  else if (typeof define == "function" && define.amd) // AMD
-    define(["../../lib/codemirror", "../haskell/haskell"], mod)
-  else // Plain browser env
-    mod(CodeMirror)
-})(function (CodeMirror) {
-  "use strict"
-
-  CodeMirror.defineMode("haskell-literate", function (config, parserConfig) {
-    var baseMode = CodeMirror.getMode(config, (parserConfig && parserConfig.base) || "haskell")
-
-    return {
-      startState: function () {
-        return {
-          inCode: false,
-          baseState: CodeMirror.startState(baseMode)
-        }
-      },
-      token: function (stream, state) {
-        if (stream.sol()) {
-          if (state.inCode = stream.eat(">"))
-            return "meta"
-        }
-        if (state.inCode) {
-          return baseMode.token(stream, state.baseState)
-        } else {
-          stream.skipToEnd()
-          return "comment"
-        }
-      },
-      innerMode: function (state) {
-        return state.inCode ? {state: state.baseState, mode: baseMode} : null
-      }
-    }
-  }, "haskell")
-
-  CodeMirror.defineMIME("text/x-literate-haskell", "haskell-literate")
-});

data/vendor/assets/javascripts/codemirror/5.49.2/mode/haskell-literate/index.html

@@ -1,282 +0,0 @@
-<!doctype html>
-
-<title>CodeMirror: Haskell-literate mode</title>
-<meta charset="utf-8"/>
-<link rel=stylesheet href="../../doc/docs.css">
-
-<link rel="stylesheet" href="../../lib/codemirror.css">
-<script src="../../lib/codemirror.js"></script>
-<script src="haskell-literate.js"></script>
-<script src="../haskell/haskell.js"></script>
-<style>.CodeMirror {
-  border-top    : 1px solid #DDDDDD;
-  border-bottom : 1px solid #DDDDDD;
-}</style>
-<div id=nav>
-  <a href="https://codemirror.net"><h1>CodeMirror</h1><img id=logo
-                                                          src="../../doc/logo.png"></a>
-
-  <ul>
-    <li><a href="../../index.html">Home</a>
-    <li><a href="../../doc/manual.html">Manual</a>
-    <li><a href="https://github.com/codemirror/codemirror">Code</a>
-  </ul>
-  <ul>
-    <li><a href="../index.html">Language modes</a>
-    <li><a class=active href="#">Haskell-literate</a>
-  </ul>
-</div>
-
-<article>
-  <h2>Haskell literate mode</h2>
-  <form>
-    <textarea id="code" name="code">
-> {-# LANGUAGE OverloadedStrings #-}
-> {-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
-> import Control.Applicative ((<$>), (<*>))
-> import Data.Maybe (isJust)
-
-> import Data.Text (Text)
-> import Text.Blaze ((!))
-> import qualified Data.Text as T
-> import qualified Happstack.Server as Happstack
-> import qualified Text.Blaze.Html5 as H
-> import qualified Text.Blaze.Html5.Attributes as A
-
-> import Text.Digestive
-> import Text.Digestive.Blaze.Html5
-> import Text.Digestive.Happstack
-> import Text.Digestive.Util
-
-Simple forms and validation
----------------------------
-
-Let's start by creating a very simple datatype to represent a user:
-
-> data User = User
->     { userName :: Text
->     , userMail :: Text
->     } deriving (Show)
-
-And dive in immediately to create a `Form` for a user. The `Form v m a` type
-has three parameters:
-
-- `v`: the type for messages and errors (usually a `String`-like type, `Text` in
-  this case);
-- `m`: the monad we are operating in, not specified here;
-- `a`: the return type of the `Form`, in this case, this is obviously `User`.
-
-> userForm :: Monad m => Form Text m User
-
-We create forms by using the `Applicative` interface. A few form types are
-provided in the `Text.Digestive.Form` module, such as `text`, `string`,
-`bool`...
-
-In the `digestive-functors` library, the developer is required to label each
-field using the `.:` operator. This might look like a bit of a burden, but it
-allows you to do some really useful stuff, like separating the `Form` from the
-actual HTML layout.
-
-> userForm = User
->     <$> "name" .: text Nothing
->     <*> "mail" .: check "Not a valid email address" checkEmail (text Nothing)
-
-The `check` function enables you to validate the result of a form. For example,
-we can validate the email address with a really naive `checkEmail` function.
-
-> checkEmail :: Text -> Bool
-> checkEmail = isJust . T.find (== '@')
-
-More validation
----------------
-
-For our example, we also want descriptions of Haskell libraries, and in order to
-do that, we need package versions...
-
-> type Version = [Int]
-
-We want to let the user input a version number such as `0.1.0.0`. This means we
-need to validate if the input `Text` is of this form, and then we need to parse
-it to a `Version` type. Fortunately, we can do this in a single function:
-`validate` allows conversion between values, which can optionally fail.
-
-`readMaybe :: Read a => String -> Maybe a` is a utility function imported from
-`Text.Digestive.Util`.
-
-> validateVersion :: Text -> Result Text Version
-> validateVersion = maybe (Error "Cannot parse version") Success .
->     mapM (readMaybe . T.unpack) . T.split (== '.')
-
-A quick test in GHCi:
-
-    ghci> validateVersion (T.pack "0.3.2.1")
-    Success [0,3,2,1]
-    ghci> validateVersion (T.pack "0.oops")
-    Error "Cannot parse version"
-
-It works! This means we can now easily add a `Package` type and a `Form` for it:
-
-> data Category = Web | Text | Math
->     deriving (Bounded, Enum, Eq, Show)
-
-> data Package = Package Text Version Category
->     deriving (Show)
-
-> packageForm :: Monad m => Form Text m Package
-> packageForm = Package
->     <$> "name"     .: text Nothing
->     <*> "version"  .: validate validateVersion (text (Just "0.0.0.1"))
->     <*> "category" .: choice categories Nothing
->   where
->     categories = [(x, T.pack (show x)) | x <- [minBound .. maxBound]]
-
-Composing forms
----------------
-
-A release has an author and a package. Let's use this to illustrate the
-composability of the digestive-functors library: we can reuse the forms we have
-written earlier on.
-
-> data Release = Release User Package
->     deriving (Show)
-
-> releaseForm :: Monad m => Form Text m Release
-> releaseForm = Release
->     <$> "author"  .: userForm
->     <*> "package" .: packageForm
-
-Views
------
-
-As mentioned before, one of the advantages of using digestive-functors is
-separation of forms and their actual HTML layout. In order to do this, we have
-another type, `View`.
-
-We can get a `View` from a `Form` by supplying input. A `View` contains more
-information than a `Form`, it has:
-
-- the original form;
-- the input given by the user;
-- any errors that have occurred.
-
-It is this view that we convert to HTML. For this tutorial, we use the
-[blaze-html] library, and some helpers from the `digestive-functors-blaze`
-library.
-
-[blaze-html]: http://jaspervdj.be/blaze/
-
-Let's write a view for the `User` form. As you can see, we here refer to the
-different fields in the `userForm`. The `errorList` will generate a list of
-errors for the `"mail"` field.
-
-> userView :: View H.Html -> H.Html
-> userView view = do
->     label     "name" view "Name: "
->     inputText "name" view
->     H.br
->
->     errorList "mail" view
->     label     "mail" view "Email address: "
->     inputText "mail" view
->     H.br
-
-Like forms, views are also composable: let's illustrate that by adding a view
-for the `releaseForm`, in which we reuse `userView`. In order to do this, we
-take only the parts relevant to the author from the view by using `subView`. We
-can then pass the resulting view to our own `userView`.
-We have no special view code for `Package`, so we can just add that to
-`releaseView` as well. `childErrorList` will generate a list of errors for each
-child of the specified form. In this case, this means a list of errors from
-`"package.name"` and `"package.version"`. Note how we use `foo.bar` to refer to
-nested forms.
-
-> releaseView :: View H.Html -> H.Html
-> releaseView view = do
->     H.h2 "Author"
->     userView $ subView "author" view
->
->     H.h2 "Package"
->     childErrorList "package" view
->
->     label     "package.name" view "Name: "
->     inputText "package.name" view
->     H.br
->
->     label     "package.version" view "Version: "
->     inputText "package.version" view
->     H.br
->
->     label       "package.category" view "Category: "
->     inputSelect "package.category" view
->     H.br
-
-The attentive reader might have wondered what the type parameter for `View` is:
-it is the `String`-like type used for e.g. error messages.
-But wait! We have
-    releaseForm :: Monad m => Form Text m Release
-    releaseView :: View H.Html -> H.Html
-... doesn't this mean that we need a `View Text` rather than a `View Html`?  The
-answer is yes -- but having `View Html` allows us to write these views more
-easily with the `digestive-functors-blaze` library. Fortunately, we will be able
-to fix this using the `Functor` instance of `View`.
-    fmap :: Monad m => (v -> w) -> View v -> View w
-A backend
----------
-To finish this tutorial, we need to be able to actually run this code. We need
-an HTTP server for that, and we use [Happstack] for this tutorial. The
-`digestive-functors-happstack` library gives about everything we need for this.
-[Happstack]: http://happstack.com/
-
-> site :: Happstack.ServerPart Happstack.Response
-> site = do
->     Happstack.decodeBody $ Happstack.defaultBodyPolicy "/tmp" 4096 4096 4096
->     r <- runForm "test" releaseForm
->     case r of
->         (view, Nothing) -> do
->             let view' = fmap H.toHtml view
->             Happstack.ok $ Happstack.toResponse $
->                 template $
->                     form view' "/" $ do
->                         releaseView view'
->                         H.br
->                         inputSubmit "Submit"
->         (_, Just release) -> Happstack.ok $ Happstack.toResponse $
->             template $ do
->                 css
->                 H.h1 "Release received"
->                 H.p $ H.toHtml $ show release
->
-> main :: IO ()
-> main = Happstack.simpleHTTP Happstack.nullConf site
-
-Utilities
----------
-
-> template :: H.Html -> H.Html
-> template body = H.docTypeHtml $ do
->     H.head $ do
->         H.title "digestive-functors tutorial"
->         css
->     H.body body
-> css :: H.Html
-> css = H.style ! A.type_ "text/css" $ do
->     "label {width: 130px; float: left; clear: both}"
->     "ul.digestive-functors-error-list {"
->     "    color: red;"
->     "    list-style-type: none;"
->     "    padding-left: 0px;"
->     "}"
-    </textarea>
-  </form>
-
-  <p><strong>MIME types
-  defined:</strong> <code>text/x-literate-haskell</code>.</p>
-
-  <p>Parser configuration parameters recognized: <code>base</code> to
-  set the base mode (defaults to <code>"haskell"</code>).</p>
-
-  <script>
-    var editor = CodeMirror.fromTextArea(document.getElementById("code"), {mode: "haskell-literate"});
-  </script>
-
-</article>