Add text source (#57)

* Add text source

* Add newline and tab to prelude ch namespace

* Undo accidental interpolation in prelude doc

Author: gmorpheme

lib/prelude.eu

@@ -295,6 +295,13 @@ zero?(n): n = 0
 ##
 ## Text and regexes
 ##
+` { export: :suppress
+    doc: "We don't support the usual string escapes so these make it a little more convenient to use interpolation instead.."}
+ch: {
+  n: "
+"
+  t: "	"
+}
 
 ` :suppress
 str: {
@@ -439,20 +446,35 @@ assertions: {
     export: :suppress 
     associates: :left
     precedence: :meta }
-(e //= v): e with-meta({ assert: __EQ(v)}) assertions.check
+(e //= v): e with-meta({ assert: (= v)}) assertions.check
 
 ` { doc: "`e //=> v` - add metadata to assert expression `e` evaluates to `v` and return value of `e`."
     export: :suppress 
     associates: :left
     precedence: :meta }
-(e //=> v): e with-meta({ assert: __EQ(v)}) assertions.checked
+(e //=> v): e with-meta({ assert: (= v)}) assertions.checked
 
 ` { doc: "`e //=? f` - add metadata to assert expression `e` satisfies function `f` and return value of `e`."
     export: :suppress 
     associates: :left
     precedence: :meta }
 (e //=? f): e with-meta({ assert: f}) assertions.checked
 
+` { doc: "`e //!? f` - add metadata to assert expression `e` satisfies function `f` and return value of `e`."
+    export: :suppress 
+    associates: :left
+    precedence: :meta }
+(e //!? f): e with-meta({ assert: complement(f)}) assertions.checked
+
+` { doc: "`e //! f` - add metadata to assert expression `e` is true and return value of `e`."
+    export: :suppress 
+    precedence: :meta }
+(e //!): e with-meta({ assert: (= true) }) assertions.checked
+
+` { doc: "`e //!! f` - add metadata to assert expression `e` is false and return value of `e`."
+    export: :suppress 
+    precedence: :meta }
+(e //!!): e with-meta({ assert: (= false) }) assertions.checked
 
 #
 # List library functions, maps and folds
@@ -655,7 +677,7 @@ select-items(f, b): b elements filter(f)
 match-select-values(re, b): b select-items(by-key-match(re)) map(value)
 
 ` "`select-values(p?, b)` - return items from block `b` where values match predicate `p?`"
-select-values(p?, b): b map(value) filter(p?)
+select-values(p?, b): b values filter(p?)
 
 ` :suppress
 _block: {

package.yaml

@@ -8,6 +8,7 @@ copyright:           "2018 Greg Hawkins"
 
 extra-source-files:
 - README.md
+- lib/prelude.eu
 
 synopsis:            Haskell implementation of Eucalypt tooling and language
 description:         Please see the README on Github at <https://github.com/curvelogic/eucalypt-hs#readme>

src/Eucalypt/Driver/Core.hs

@@ -39,6 +39,7 @@ import Eucalypt.Driver.Lib (getResource)
 import Eucalypt.Driver.Options (EucalyptOptions(..))
 import Eucalypt.Reporting.Error (EucalyptError(..))
 import Eucalypt.Source.Error (DataParseException(..))
+import Eucalypt.Source.TextSource
 import Eucalypt.Source.TomlSource
 import Eucalypt.Source.YamlSource
 import Eucalypt.Syntax.Ast (Unit)
@@ -136,6 +137,7 @@ loadUnit i@(Input locator name format) = do
   coreUnit <-
     liftIO $
     case format of
+      "text" -> textDataToCore source
       "toml" -> tomlDataToCore source
       "yaml" -> activeYamlToCore source
       "json" -> yamlDataToCore source
@@ -157,7 +159,8 @@ loadUnit i@(Input locator name format) = do
       case r of
         Left e -> (return . Left . Source) e
         Right core -> (return . Right . maybeApplyName . dataUnit) core
-    tomlDataToCore text = parseTomlData text >>= (return . Right <$> dataUnit)
+    textDataToCore text = parseTextLines text >>= (return . Right . maybeApplyName <$> dataUnit)
+    tomlDataToCore text = parseTomlData text >>= (return . Right .maybeApplyName <$> dataUnit)
     activeYamlToCore text = do
       r <- try (parseYamlExpr text) :: IO (Either DataParseException CoreExpr)
       case r of

src/Eucalypt/Source/TextSource.hs

@@ -0,0 +1,19 @@
+{-|
+Module      : Eucalypt.Source.TextSource
+Description : Ingest text lines into core syntax
+Copyright   : (c) Greg Hawkins, 2018
+License     :
+Maintainer  : greg@curvelogic.co.uk
+Stability   : experimental
+-}
+module Eucalypt.Source.TextSource where
+
+import qualified Data.ByteString as BS
+import qualified Data.Text as T
+import Data.Text.Encoding (decodeUtf8)
+import Eucalypt.Core.SourceMap
+import Eucalypt.Core.Syn
+
+parseTextLines :: BS.ByteString -> IO CoreExpr
+parseTextLines =
+  return . anon corelist . map (anon str . T.unpack) . T.lines . decodeUtf8

src/Eucalypt/Syntax/Input.hs

@@ -72,6 +72,7 @@ inferFormat loc =
     extToFormat ext =
       case ext of
         ".json" -> Just "json"
+        ".txt" -> Just "text"
         ".toml" -> Just "toml"
         ".yaml" -> Just "yaml"
         ".yml" -> Just "yaml"

test/Eucalypt/Source/TextSourceSpec.hs

@@ -0,0 +1,22 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Eucalypt.Source.TextSourceSpec
+  ( main
+  , spec
+  ) where
+
+import Eucalypt.Core.AnonSyn
+import Eucalypt.Source.TextSource
+import Data.Text
+import Data.Text.Encoding
+import Test.Hspec
+
+main :: IO ()
+main = hspec spec
+
+spec :: Spec
+spec =
+  describe "Text source" $
+  it "reads as list" $
+  parseTextLines (encodeUtf8 $ pack "one\ntwo\nthree\nξ") `shouldReturn`
+  corelist [str "one", str "two", str "three", str "ξ"]