packages feed

neat-interpolation 0.3.2.5 → 0.3.2.6

raw patch · 7 files changed

+179/−120 lines, 7 filesdep +QuickCheckdep +quickcheck-instancesdep +rerebasedep −HTFdep −base-preludePVP ok

version bump matches the API change (PVP)

Dependencies added: QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit, tasty-quickcheck

Dependencies removed: HTF, base-prelude

API changes (from Hackage documentation)

Files

− executables/APITests.hs 
@@ -1,49 +0,0 @@-{-# OPTIONS_GHC -F -pgmF htfpp #-}--import BasePrelude-import Test.Framework-import NeatInterpolation---main = htfMain $ htf_thisModulesTests---test_demo = do-  assertEqual-    "function(){\n  function(){\n    {\n      indented line\n      indented line\n    }\n  }\n  return {\n    indented line\n    indented line\n  }\n}\n"-    (template a a)-  assertEqual-    "this_could_be_one_long_identifier\n"-    (escaped "one")-  where-    template a b = -      [text|-        function(){-          function(){-            $a-          }-          return $b-        }-      |]-    escaped name = [text|this_could_be_${name}_long_identifier|]-    a = "{\n  indented line\n  indented line\n}"--test_dollar = do-  assertEqual-    "function(){\n  function(){\n    {\n      indented line\n      indented line\n    }\n  }\n  return \"$b\"\n}\n"-    (template a a)-  assertEqual-    "this_could_be_$one$_long_identifier\n"-    (escaped "one")-  where-    template a b = -      [text|-        function(){-          function(){-            $a-          }-          return "$$b"-        }-      |]-    escaped name = [text|this_could_be_$$${name}$$_long_identifier|]-    a = "{\n  indented line\n  indented line\n}"
library/NeatInterpolation.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS_GHC -fno-warn-missing-fields #-} -- | -- NeatInterpolation provides a quasiquoter for producing strings -- with a simple interpolation of input values.@@ -81,10 +80,10 @@ -- > f "funny" == "$my funny ${string}|] module NeatInterpolation (text) where -import BasePrelude+import NeatInterpolation.Prelude  import Language.Haskell.TH-import Language.Haskell.TH.Quote+import Language.Haskell.TH.Quote hiding (quoteExp)  import NeatInterpolation.String import NeatInterpolation.Parsing@@ -96,19 +95,17 @@ -- | -- The quasiquoter. text :: QuasiQuoter-text = QuasiQuoter {quoteExp = quoteExprExp}+text = QuasiQuoter quoteExp notSupported notSupported notSupported where+  notSupported _ = fail "Quotation in this context is not supported" --- |--- A function used internally by the quasiquoter. Just ignore it. indentQQPlaceholder :: Int -> Text -> Text indentQQPlaceholder indent text = case T.lines text of-  head:tail -> T.intercalate (T.pack "\n") $+  head:tail -> T.intercalate (T.singleton '\n') $                head : map (T.replicate indent (T.singleton ' ') <>) tail   [] -> text --quoteExprExp :: String -> Q Exp-quoteExprExp input =+quoteExp :: String -> Q Exp+quoteExp input =   case parseLines $ normalizeQQInput input of     Left e -> fail $ show e     Right lines -> sigE (appE [|T.unlines|] $ listE $ map lineExp lines)
library/NeatInterpolation/Parsing.hs view
@@ -1,6 +1,6 @@ module NeatInterpolation.Parsing where -import BasePrelude hiding (many, some, try, (<|>))+import NeatInterpolation.Prelude hiding (many, some, try, (<|>)) import Data.Text (Text, pack) import Text.Megaparsec hiding (Line) import Text.Megaparsec.Char
+ library/NeatInterpolation/Prelude.hs view
@@ -0,0 +1,79 @@+module NeatInterpolation.Prelude+( +  module Exports,+)+where++-- base+-------------------------+import Control.Applicative as Exports+import Control.Arrow as Exports hiding (first, second)+import Control.Category as Exports+import Control.Concurrent as Exports+import Control.Exception as Exports+import Control.Monad as Exports hiding (fail, mapM_, sequence_, forM_, msum, mapM, sequence, forM)+import Control.Monad.IO.Class as Exports+import Control.Monad.Fail as Exports+import Control.Monad.Fix as Exports hiding (fix)+import Control.Monad.ST as Exports+import Data.Bifunctor as Exports+import Data.Bits as Exports+import Data.Bool as Exports+import Data.Char as Exports+import Data.Coerce as Exports+import Data.Complex as Exports+import Data.Data as Exports+import Data.Dynamic as Exports+import Data.Either as Exports+import Data.Fixed as Exports+import Data.Foldable as Exports hiding (toList)+import Data.Function as Exports hiding (id, (.))+import Data.Functor as Exports+import Data.Functor.Contravariant as Exports+import Data.Functor.Identity as Exports+import Data.Int as Exports+import Data.IORef as Exports+import Data.Ix as Exports+import Data.List as Exports hiding (sortOn, isSubsequenceOf, uncons, concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl')+import Data.Maybe as Exports+import Data.Monoid as Exports hiding (Last(..), First(..), (<>))+import Data.Ord as Exports+import Data.Proxy as Exports+import Data.Ratio as Exports+import Data.Semigroup as Exports+import Data.STRef as Exports+import Data.String as Exports+import Data.Traversable as Exports+import Data.Tuple as Exports+import Data.Unique as Exports+import Data.Version as Exports+import Data.Void as Exports+import Data.Word as Exports+import Debug.Trace as Exports+import Foreign.ForeignPtr as Exports+import Foreign.Ptr as Exports+import Foreign.StablePtr as Exports+import Foreign.Storable as Exports hiding (sizeOf, alignment)+import GHC.Conc as Exports hiding (withMVar, threadWaitWriteSTM, threadWaitWrite, threadWaitReadSTM, threadWaitRead)+import GHC.Exts as Exports (lazy, inline, sortWith, groupWith, IsList(..))+import GHC.Generics as Exports (Generic, Generic1)+import GHC.IO.Exception as Exports+import Numeric as Exports+import Prelude as Exports hiding (fail, concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.))+import System.Environment as Exports+import System.Exit as Exports+import System.IO as Exports+import System.IO.Error as Exports+import System.IO.Unsafe as Exports+import System.Mem as Exports+import System.Mem.StableName as Exports+import System.Timeout as Exports+import Text.ParserCombinators.ReadP as Exports (ReadP, ReadS, readP_to_S, readS_to_P)+import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readPrec_to_P, readP_to_Prec, readPrec_to_S, readS_to_Prec)+import Text.Printf as Exports (printf, hPrintf)+import Text.Read as Exports (Read(..), readMaybe, readEither)+import Unsafe.Coerce as Exports++-- text+-------------------------+import Data.Text as Exports (Text)
library/NeatInterpolation/String.hs view
@@ -1,6 +1,6 @@ module NeatInterpolation.String where -import BasePrelude+import NeatInterpolation.Prelude   normalizeQQInput :: [Char] -> [Char]
neat-interpolation.cabal view
@@ -1,77 +1,53 @@-name:-  neat-interpolation-version:-  0.3.2.5-synopsis:-  A quasiquoter for neat and simple multiline text interpolation+name: neat-interpolation+version: 0.3.2.6+synopsis: A quasiquoter for neat and simple multiline text interpolation description:   A quasiquoter for producing Text values with support for   a simple interpolation of input values.   It removes the excessive indentation from the input and   accurately manages the indentation of all lines of the interpolated variables.-category:-  String, QuasiQuotes-license:-  MIT-license-file:-  LICENSE-copyright:-  (c) 2013, Nikita Volkov-author:-  Nikita Volkov <nikita.y.volkov@mail.ru>-maintainer:-  Nikita Volkov <nikita.y.volkov@mail.ru>-homepage:-  https://github.com/nikita-volkov/neat-interpolation-bug-reports:-  https://github.com/nikita-volkov/neat-interpolation/issues-build-type:-  Simple-cabal-version:-  >=1.10-+category: String, QuasiQuotes+license: MIT+license-file: LICENSE+copyright: (c) 2013, Nikita Volkov+author: Nikita Volkov <nikita.y.volkov@mail.ru>+maintainer: Nikita Volkov <nikita.y.volkov@mail.ru>+homepage: https://github.com/nikita-volkov/neat-interpolation+bug-reports: https://github.com/nikita-volkov/neat-interpolation/issues+build-type: Simple+cabal-version: >=1.10  source-repository head-  type:-    git-  location:-    git://github.com/nikita-volkov/neat-interpolation.git-+  type: git+  location: git://github.com/nikita-volkov/neat-interpolation.git  library-  hs-source-dirs:-    library+  hs-source-dirs: library+  default-extensions: BangPatterns, BinaryLiterals, BlockArguments, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, DuplicateRecordFields, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, HexFloatLiterals, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, NumericUnderscores, OverloadedLists, OverloadedStrings, PatternGuards, PatternSynonyms, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, StrictData, TemplateHaskell, TupleSections, TypeApplications, TypeFamilies, TypeOperators, UnboxedTuples+  default-language: Haskell2010   exposed-modules:     NeatInterpolation   other-modules:     NeatInterpolation.Parsing+    NeatInterpolation.Prelude     NeatInterpolation.String   build-depends:-    text == 1.*,-    megaparsec >= 7 && < 9,-    template-haskell >= 2.8 && < 3,-    base-prelude < 2,-    base >= 4.9 && < 5-  ghc-options:-    -funbox-strict-fields-  default-extensions:-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFunctor, DeriveGeneric, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples-  default-language:-    Haskell2010-+    base >=4.9 && <5,+    megaparsec >=7 && <9,+    template-haskell >=2.8 && <3,+    text ==1.* -test-suite api-tests-  type:-    exitcode-stdio-1.0-  hs-source-dirs:-    executables-  main-is:-    APITests.hs+test-suite test+  type: exitcode-stdio-1.0+  hs-source-dirs: test+  default-extensions: BangPatterns, BinaryLiterals, BlockArguments, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, DuplicateRecordFields, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, HexFloatLiterals, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, NumericUnderscores, OverloadedLists, OverloadedStrings, PatternGuards, PatternSynonyms, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, StrictData, TemplateHaskell, TupleSections, TypeApplications, TypeFamilies, TypeOperators, UnboxedTuples+  default-language: Haskell2010+  main-is: Main.hs   build-depends:     neat-interpolation,-    HTF >= 0.11 && < 0.14,-    base-prelude-  default-extensions:-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFunctor, DeriveGeneric, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples-  default-language:-    Haskell2010+    QuickCheck >=2.13 && <3,+    quickcheck-instances >=0.3.22 && <0.4,+    rerebase <2,+    tasty >=1.2.3 && <2,+    tasty-hunit >=0.10.0.2 && <0.11,+    tasty-quickcheck >=0.10.1 && <0.11
+ test/Main.hs view
@@ -0,0 +1,56 @@+module Main where++import Prelude hiding (choose)+import Test.QuickCheck.Instances+import Test.Tasty+import Test.Tasty.Runners+import Test.Tasty.HUnit+import Test.Tasty.QuickCheck+import NeatInterpolation+import qualified Test.QuickCheck as QuickCheck+import qualified Test.QuickCheck.Property as QuickCheck+++main = defaultMain $ testGroup "" $+  [+    testCase "Demo" $ let+      template a b = +        [text|+          function(){+            function(){+              $a+            }+            return $b+          }+        |]+      a = "{\n  indented line\n  indented line\n}"+      in assertEqual ""+          "function(){\n  function(){\n    {\n      indented line\n      indented line\n    }\n  }\n  return {\n    indented line\n    indented line\n  }\n}\n"+          (template a a)+    ,+    testCase "Isolation" $ let+      isolated name = [text|this_could_be_${name}_long_identifier|]+      in assertEqual ""+          "this_could_be_one_long_identifier\n"+          (isolated "one")+    ,+    testCase "Escaping" $ let+      template a b = +        [text|+          function(){+            function(){+              $a+            }+            return "$$b"+          }+        |]+      escaped name = [text|this_could_be_$$${name}$$_long_identifier|]+      a = "{\n  indented line\n  indented line\n}"+      in do+        assertEqual ""+          "function(){\n  function(){\n    {\n      indented line\n      indented line\n    }\n  }\n  return \"$b\"\n}\n"+          (template a a)+        assertEqual ""+          "this_could_be_$one$_long_identifier\n"+          (escaped "one")+  ]