├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── Setup.hs
├── devrepo
    ├── haskeleton.tar.metainfo
    ├── haskeleton
    │   ├── .gitattributes
    │   ├── .gitignore
    │   ├── .stylish-haskell.yaml
    │   ├── .travis.yml
    │   ├── CHANGELOG.md
    │   ├── HLint.hs
    │   ├── Haskeleton.hs.template
    │   ├── LICENSE-HASKELETON.md
    │   ├── LICENSE.md.template
    │   ├── Makefile.template
    │   ├── ProjectName.cabal.template
    │   ├── README-HASKELETON.md
    │   ├── README.md.template
    │   ├── Setup.hs
    │   ├── benchmark
    │   │   ├── Bench.hs.template
    │   │   └── ProjectNameBench.hs.template
    │   ├── executable
    │   │   └── Main.hs.template
    │   ├── library
    │   │   └── ProjectName.hs.template
    │   └── test-suite
    │   │   ├── DocTest.hs
    │   │   ├── HLint.hs
    │   │   ├── HPC.hs
    │   │   ├── Haddock.hs
    │   │   ├── ProjectNameSpec.hs.template
    │   │   └── Spec.hs
    ├── servant.tar.metainfo
    ├── servant
    │   ├── .projectile
    │   ├── LICENSE
    │   ├── ProjectName.cabal.template
    │   ├── Setup.hs
    │   ├── app
    │   │   └── Main.hs
    │   ├── application.conf.template
    │   ├── mysql.sql.template
    │   ├── src
    │   │   ├── AppConfig.hs
    │   │   ├── Auth
    │   │   │   ├── AuthHeader.hs
    │   │   │   └── DbAuth.hs
    │   │   ├── Convert
    │   │   │   └── UserConverter.hs
    │   │   ├── Db
    │   │   │   ├── Common.hs
    │   │   │   └── User.hs
    │   │   ├── Json
    │   │   │   └── User.hs
    │   │   └── Lib.hs
    │   ├── stack.yaml
    │   └── test
    │   │   └── Spec.hs
    ├── srv-converter
    ├── srv-converter.metainfo
    ├── srv-crud
    ├── srv-crud.metainfo
    ├── srv-db-entity
    ├── srv-db-entity.metainfo
    ├── srv-json-entity
    └── srv-json-entity.metainfo
├── img
    └── trurl.jpg
├── repository
    ├── registry.json
    └── templates
    │   ├── haskeleton.tar
    │   ├── haskeleton.tar.metainfo
    │   ├── servant.tar
    │   ├── servant.tar.metainfo
    │   ├── srv-converter
    │   ├── srv-converter.metainfo
    │   ├── srv-crud
    │   ├── srv-crud.metainfo
    │   ├── srv-db-entity
    │   ├── srv-db-entity.metainfo
    │   ├── srv-json-entity
    │   └── srv-json-entity.metainfo
├── src
    ├── Main.hs
    ├── Registry.hs
    ├── SimpleParams.hs
    └── Trurl.hs
├── stack.yaml
├── tests
    └── Main.hs
└── trurl.cabal


/.gitignore:
--------------------------------------------------------------------------------
1 | .stack-work/
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | 
 3 | cache:
 4 |   directories:
 5 |     - $HOME/.stack
 6 | 
 7 | matrix:
 8 |   include:
 9 |   - env: GHCVER=7.10.2 STACK_YAML=stack.yaml
10 |     addons:
11 |       apt:
12 |         sources: [hvr-ghc]
13 |         packages: [ghc-7.10.2]
14 | 
15 | before_install:
16 |   - mkdir -p ~/.local/bin
17 |   - export PATH=/opt/ghc/$GHCVER/bin:$HOME/.local/bin:$PATH
18 |   - travis_retry curl -L https://github.com/commercialhaskell/stack/releases/download/v0.1.2.0/stack-0.1.2.0-x86_64-linux.gz | gunzip > ~/.local/bin/stack
19 |   - chmod a+x ~/.local/bin/stack
20 | 
21 | script:
22 |   - stack --no-terminal --skip-ghc-check setup
23 |   - stack --no-terminal --skip-ghc-check build --ghc-options "-Wall -Werror"
24 |   - stack --no-terminal --skip-ghc-check test  --ghc-options "-Wall -Werror"
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015, dbushenko
 2 | 
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are met:
 7 | 
 8 |     * Redistributions of source code must retain the above copyright
 9 |       notice, this list of conditions and the following disclaimer.
10 | 
11 |     * Redistributions in binary form must reproduce the above
12 |       copyright notice, this list of conditions and the following
13 |       disclaimer in the documentation and/or other materials provided
14 |       with the distribution.
15 | 
16 |     * Neither the name of dbushenko nor the names of other
17 |       contributors may be used to endorse or promote products derived
18 |       from this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Overview
  2 | 
  3 | [![Build Status](https://travis-ci.org/dbushenko/trurl.png?branch=master)](https://travis-ci.org/dbushenko/trurl)
  4 | 
  5 | Trurl is a haskell scaffolding tool named after great hyper-space engineer-constructor Trurl who (with his friend Klapaucius) is the hero of Stanislaw Lem's fiction.
  6 | 
  7 | ![Trurl](https://raw.githubusercontent.com/dbushenko/trurl/master/img/trurl.jpg "Trurl")
  8 | 
  9 | The tool is able to create template projects of any type and template files of any type. Though it was intended to generate template haskell code, you may also generate html/css/js in web projects and any other text files.
 10 | 
 11 | ## Installation
 12 | 
 13 | Build it from source using stack:
 14 | 
 15 |     git clone https://github.com/dbushenko/trurl.git
 16 |     cd trurl
 17 |     stack build
 18 |     stack install
 19 | 
 20 | ## Quick Start
 21 | 
 22 | Run following to create a template project:
 23 | 
 24 |     trurl new project MyProject haskeleton
 25 | 
 26 | ## Usage
 27 | 
 28 | Just run 'trurl' to see the help:
 29 | 
 30 |     trurl <command> [parameters]
 31 |       update -- fetch the updates from repository
 32 |       new project <name> <project_template> -j [parameters_string] -- create project of specified type with specified name; optionally add JSON parameters, wrap it with \"\" or ''
 33 |       new project <name> <project_template> [parameters] -- create project of specified type with specified name; optionally add parameters
 34 |       new file <name> <file_template> -j [parameters_string] -- create file from the template with specified JSON parameters, wrap it with "" or ''
 35 |       new file <name> <file_template> [parameters] -- create file from the template with specified string parameters
 36 |       list -- print all available templates
 37 |       help <template> -- print template info
 38 |       help -- print this help
 39 |       version -- print version
 40 |   
 41 | * Command 'update' fetches all the latest templates from the repository. Run it before using any other command.
 42 | * Command 'list' shows available templates. Technically it finds all the files *.metainfo in $HOME/.trurl/repo and prints thir first lines.
 43 | * Command 'help <template>' prints detailed info about the template.
 44 | * Command 'new project' intended to generate projects, just specify an available project template name. You may also sepcify optional parameters. In any case at least one parameter will be available in project template -- 'ProjectName' which corresponds to the provided <name> parameter.
 45 | * Command 'new file' generates template file, generated file will be named as specified in 'name'. It uses Mustache format in templates and accepts mandatory parameters. In any case at least one parameter will be available in the file template -- 'FileName' which corresponds to the provided <name> parameter.
 46 | 
 47 | Parameters for commands 'new project' and 'new file' may be of two types: JSON and simple string.
 48 | 
 49 | * JSON parameters might look like this: '{"entityName": "Article", "params": [ {"key":"title","value":"String"}, {"key":"body", "value":"String"}]}"
 50 | * Totally the same simple string looks like this: 'entityName:Article, params: [ title#String, body#String ]'
 51 | 
 52 | Simple string parameters use following rules to correspond to JSON:
 53 | 
 54 | * abc:efg is converted to "abc":"efg"
 55 | * abc:123 is converted to "abc":123
 56 | * abc#efg is converted to {"key":"abc", "value":"efg"} -- this conversion is especially useful when generating object with list of properties.
 57 | * abc#efg@ is converted to {"key":"abc", "value":"efg", "last":true} -- this conversion is needed when generating list of properties and you need to avoid last separator (comma, whitespace, etc).
 58 | 
 59 | For example, if there is a template file 'file1.txt' with following contents:
 60 | 
 61 | ```
 62 | The list: 
 63 | 
 64 | {{#heroes}}
 65 |     * {{name}}
 66 | {{/heroes}}
 67 | 
 68 | MyObj:
 69 | {{#myobj}}
 70 | {{opt1}}
 71 | {{/myobj}}
 72 | ```
 73 | 
 74 | Run trurl as following:
 75 | 
 76 |     trurl new file1.txt -j '{"heroes":[{"name":"1"},{"name":"22"}],"myobj":{"opt1":"value1"}}'
 77 | 
 78 | Then you'll get:
 79 | 
 80 | ```
 81 | The list: 
 82 | 
 83 |     * 1
 84 |     * 22
 85 | 
 86 | MyObj:
 87 | value1
 88 | ```
 89 | 
 90 | ## Creating templates
 91 | 
 92 | All the templates are stored in $HOME/.trurl/repo. There are two types of templates: projects and files.
 93 | 
 94 | * Project template is just a tar archive which is unpacked in specified directory. Template files should have extension '.template' and use the same mustache syntax as templates for command 'new'. In any case at least one parameter will be available in project template -- 'ProjectName' which corresponds to the provided <name> parameter. All files named as 'ProjectName' will be renamed according to specified project name. E.g. if creating project 'my' and there is somewhere file 'ProjectName.html' then it will be renamed to 'my.html'.
 95 | * File template is a file in Mustache format.
 96 | 
 97 | 
 98 | Info about each template is stored in corresponding metainfo file. E.g. if there is template 'file1.hs' then should be also 'file1.hs.metainfo'. First line of the metainfo file is its short description printed by the 'list' command.
 99 | 
100 | See examples of the templates in 'devrepo'.
101 | 
102 | ## Registering templates in the main repository.
103 | 
104 | Just add a pull request in the directory 'devrepo'. You are welcome to add your own templates here!
105 | 
106 | Author: Dmitry Bushenko (d.bushenko@gmail.com)
107 | 


--------------------------------------------------------------------------------
/Setup.hs:
--------------------------------------------------------------------------------
1 | import Distribution.Simple
2 | main = defaultMain
3 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton.tar.metainfo:
--------------------------------------------------------------------------------
 1 | haskeleton -- [new project] generic haskell project skeleton
 2 | 
 3 | The template is imported from https://github.com/tfausak/haskeleton
 4 | 
 5 | Create a new project like this:
 6 | 
 7 | $ trurl new project MyNewProject haskeleton '{"author":"Ivan Pupkin", "email":"i.pupkin@gmail.com"}'
 8 | 
 9 | or like this:
10 | 
11 | $ trurl new project MyNewProject haskeleton 'author:Ivan_Pupkin, email:i.pupkin@gmail.com'
12 | 
13 | Pay attention, the name of the project should start from upper case!


--------------------------------------------------------------------------------
/devrepo/haskeleton/.gitattributes:
--------------------------------------------------------------------------------
1 | * text=auto
2 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/.gitignore:
--------------------------------------------------------------------------------
1 | /.cabal-sandbox/
2 | /.hpc/
3 | /cabal.sandbox.config
4 | /dist/
5 | /tmp/
6 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/.stylish-haskell.yaml:
--------------------------------------------------------------------------------
 1 | columns: 79
 2 | steps:
 3 | - imports:
 4 |     align: none
 5 | - language_pragmas:
 6 |     remove_redundant: true
 7 |     style: vertical
 8 | - records: {}
 9 | - tabs:
10 |     spaces: 4
11 | - trailing_whitespace: {}
12 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/.travis.yml:
--------------------------------------------------------------------------------
1 | language: haskell
2 | ghc:
3 | - 7.8
4 | - 7.6
5 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Change log
 2 | 
 3 | This package uses [Semantic Versioning][1].
 4 | 
 5 | ## v0.0.0
 6 | 
 7 | -   Initially created.
 8 | 
 9 | [1]: http://semver.org/spec/v2.0.0.html
10 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/HLint.hs:
--------------------------------------------------------------------------------
1 | {-# LANGUAGE PackageImports #-}
2 | 
3 | module HLint () where
4 | 
5 | import "hint" HLint.Default
6 | import "hint" HLint.Dollar
7 | import "hint" HLint.Generalise
8 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/Haskeleton.hs.template:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env runhaskell
  2 | 
  3 | -- Usage: ./Haskeleton.hs New.Module
  4 | module Haskeleton (main) where
  5 | 
  6 | import Data.List (groupBy, isInfixOf)
  7 | import Data.Monoid ((<>))
  8 | import System.Directory (createDirectoryIfMissing)
  9 | import System.Environment (getArgs)
 10 | import System.FilePath (joinPath, takeDirectory, (<.>))
 11 | 
 12 | main :: IO ()
 13 | main = do
 14 |     ms <- getArgs
 15 |     mapM_ createDirectories ms
 16 |     mapM_ writeFiles ms
 17 |     mapM_ updateFiles ms
 18 |   where
 19 |     createDirectories m = do
 20 |         createBenchmarkDirectory m
 21 |         createLibraryDirectory m
 22 |         createTestSuiteDirectory m
 23 |     writeFiles m = do
 24 |         writeBenchmarkFile m
 25 |         writeLibraryFile m
 26 |         writeTestSuiteFile m
 27 |     updateFiles m = do
 28 |         updateCabal m
 29 |         updateCriterion m
 30 |         updateLibrary m
 31 | 
 32 | --
 33 | 
 34 | createDirectory :: FilePath -> IO ()
 35 | createDirectory = createDirectoryIfMissing True . takeDirectory
 36 | 
 37 | path :: FilePath -> String -> String -> FilePath
 38 | path d s m = joinPath (d : parts (m <> s)) <.> "hs"
 39 | 
 40 | parts :: String -> [String]
 41 | parts = split '.'
 42 | 
 43 | placeholder :: String
 44 | placeholder = "New.Module"
 45 | 
 46 | pragma :: String
 47 | pragma = "-- HASKELETON: "
 48 | 
 49 | replace :: (Eq a) => [a] -> [a] -> [a] -> [a]
 50 | replace [] _ _ = []
 51 | replace xs@(h : t) old new =
 52 |     if a == old
 53 |         then new <> replace b old new
 54 |         else h : replace t old new
 55 |   where
 56 |     (a, b) = splitAt (length old) xs
 57 | 
 58 | split :: (Eq a) => a -> [a] -> [[a]]
 59 | split x xs = fmap (dropWhile (== x)) (groupBy (const (x /=)) xs)
 60 | 
 61 | updateFile :: FilePath -> String -> IO ()
 62 | updateFile p m = do
 63 |     contents <- readFile p
 64 |     seq (length contents) (return ())
 65 |     writeFile p (unlines (go =<< lines contents))
 66 |   where
 67 |     go line = if pragma `isInfixOf` line
 68 |         then [replace (replace line pragma "") placeholder m, line]
 69 |         else [line]
 70 | 
 71 | -- Benchmark
 72 | 
 73 | createBenchmarkDirectory :: String -> IO ()
 74 | createBenchmarkDirectory = createDirectory . benchmarkPath
 75 | 
 76 | benchmarkDirectory :: String
 77 | benchmarkDirectory = "benchmark"
 78 | 
 79 | benchmarkPath :: String -> FilePath
 80 | benchmarkPath = path benchmarkDirectory benchmarkSuffix
 81 | 
 82 | benchmarkTemplate :: String -> String
 83 | benchmarkTemplate m = unlines
 84 |     [ "module " <> m <> "Bench (benchmarks) where"
 85 |     , ""
 86 |     , "import " <> m <> " ()"
 87 |     , ""
 88 |     , "import Criterion"
 89 |     , ""
 90 |     , "benchmarks :: [Benchmark]"
 91 |     , "benchmarks = []"
 92 |     ]
 93 | 
 94 | benchmarkSuffix :: String
 95 | benchmarkSuffix = "Bench"
 96 | 
 97 | writeBenchmarkFile :: String -> IO ()
 98 | writeBenchmarkFile m = writeFile (benchmarkPath m) (benchmarkTemplate m)
 99 | 
100 | -- Cabal
101 | 
102 | cabalPath :: FilePath
103 | cabalPath = "{{ProjectName}}.cabal"
104 | 
105 | updateCabal :: String -> IO ()
106 | updateCabal = updateFile cabalPath
107 | 
108 | -- Criterion
109 | 
110 | criterionPath :: FilePath
111 | criterionPath = benchmarkPath ""
112 | 
113 | updateCriterion :: String -> IO ()
114 | updateCriterion = updateFile criterionPath
115 | 
116 | -- Library
117 | 
118 | createLibraryDirectory :: String -> IO ()
119 | createLibraryDirectory = createDirectory . libraryPath
120 | 
121 | libraryDirectory :: String
122 | libraryDirectory = "library"
123 | 
124 | libraryPath :: String -> FilePath
125 | libraryPath = path libraryDirectory librarySuffix
126 | 
127 | libraryTemplate :: String -> String
128 | libraryTemplate m = unlines
129 |     [ "-- | TODO"
130 |     , "module " <> m <> " () where"
131 |     ]
132 | 
133 | librarySuffix :: String
134 | librarySuffix = ""
135 | 
136 | updateLibrary :: String -> IO ()
137 | updateLibrary = updateFile (libraryPath "{{ProjectName}}")
138 | 
139 | writeLibraryFile :: String -> IO ()
140 | writeLibraryFile m = writeFile (libraryPath m) (libraryTemplate m)
141 | 
142 | -- Test Suite
143 | 
144 | createTestSuiteDirectory :: String -> IO ()
145 | createTestSuiteDirectory = createDirectory . testSuitePath
146 | 
147 | testSuiteDirectory :: String
148 | testSuiteDirectory = "test-suite"
149 | 
150 | testSuitePath :: String -> FilePath
151 | testSuitePath = path testSuiteDirectory testSuiteSuffix
152 | 
153 | testSuiteTemplate :: String -> String
154 | testSuiteTemplate m = unlines
155 |     [ "module " <> m <> "Spec (spec) where"
156 |     , ""
157 |     , "import " <> m <> " ()"
158 |     , ""
159 |     , "import Test.Hspec"
160 |     , ""
161 |     , "spec :: Spec"
162 |     , "spec = it \"is\" pending"
163 |     ]
164 | 
165 | testSuiteSuffix :: String
166 | testSuiteSuffix = "Spec"
167 | 
168 | writeTestSuiteFile :: String -> IO ()
169 | writeTestSuiteFile m = writeFile (testSuitePath m) (testSuiteTemplate m)
170 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/LICENSE-HASKELETON.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Taylor Fausak <taylor@fausak.me>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/LICENSE.md.template:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 {{author}} <{{email}}>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/Makefile.template:
--------------------------------------------------------------------------------
 1 | .PHONY: all bench build clean configure haddock hpc install repl run test
 2 | 
 3 | all: install configure build haddock test hpc bench
 4 | 
 5 | bench:
 6 | 	cabal bench --jobs
 7 | 
 8 | build:
 9 | 	cabal build --jobs
10 | 
11 | clean:
12 | 	cabal clean
13 | 	if test -d .cabal-sandbox; then cabal sandbox delete; fi
14 | 	if test -d .hpc; then rm -r .hpc; fi
15 | 
16 | configure:
17 | 	cabal configure --enable-benchmarks --enable-tests
18 | 
19 | haddock:
20 | 	cabal haddock --hyperlink-source
21 | 	# dist/doc/html/{{ProjectName}}/index.html
22 | 
23 | hpc:
24 | 	hpc markup --destdir=tmp dist/hpc/tix/tests/tests.tix
25 | 	# tmp/hpc_index.html
26 | 
27 | install:
28 | 	cabal sandbox init
29 | 	cabal install --enable-benchmarks --enable-tests --jobs --only-dependencies --reorder-goals
30 | 
31 | repl:
32 | 	cabal repl lib:{{ProjectName}}
33 | 
34 | run:
35 | 	cabal run --jobs {{ProjectName}}
36 | 
37 | test:
38 | 	cabal test --jobs
39 | 	cabal check
40 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/ProjectName.cabal.template:
--------------------------------------------------------------------------------
  1 | name: {{ProjectName}}
  2 | version: 0.0.0
  3 | cabal-version: >=1.10
  4 | build-type: Simple
  5 | license: MIT
  6 | license-file: LICENSE.md
  7 | copyright: 2015 {{author}} <{{email}}>
  8 | maintainer: {{author}} <{{email}}>
  9 | synopsis: TODO
 10 | description:
 11 |     TODO
 12 | category: TODO
 13 | author: {{author}} <{{email}}>
 14 | tested-with: GHC ==7.8 GHC ==7.6
 15 | extra-source-files:
 16 |     CHANGELOG.md
 17 |     README.md
 18 | 
 19 | library
 20 |     exposed-modules:
 21 |         {{ProjectName}}
 22 |         -- HASKELETON: New.Module
 23 |     build-depends:
 24 |         base ==4.*
 25 |     default-language: Haskell2010
 26 |     hs-source-dirs: library
 27 |     ghc-prof-options: -auto-all -prof
 28 |     ghc-options: -Wall
 29 | 
 30 | executable {{ProjectName}}
 31 |     main-is: Main.hs
 32 |     build-depends:
 33 |         base -any,
 34 |         {{ProjectName}} -any
 35 |     default-language: Haskell2010
 36 |     hs-source-dirs: executable
 37 |     ghc-prof-options: -auto-all -prof
 38 |     ghc-options: -Wall
 39 | 
 40 | test-suite tests
 41 |     type: exitcode-stdio-1.0
 42 |     main-is: Spec.hs
 43 |     build-depends:
 44 |         base -any,
 45 |         {{ProjectName}} -any,
 46 |         hspec ==2.*,
 47 |         HUnit -any,
 48 |         QuickCheck -any
 49 |     default-language: Haskell2010
 50 |     hs-source-dirs: library test-suite
 51 |     other-modules:
 52 |         {{ProjectName}}
 53 |         -- HASKELETON: New.Module
 54 |         {{ProjectName}}Spec
 55 |         -- HASKELETON: New.ModuleSpec
 56 |     ghc-options: -fhpc -Wall -Werror
 57 | test-suite examples
 58 |     type: exitcode-stdio-1.0
 59 |     main-is: DocTest.hs
 60 |     build-depends:
 61 |         base -any,
 62 |         Glob ==0.7.*,
 63 |         doctest ==0.9.*
 64 |     default-language: Haskell2010
 65 |     hs-source-dirs: test-suite
 66 |     ghc-options: -Wall -Werror
 67 | test-suite coverage
 68 |     type: exitcode-stdio-1.0
 69 |     main-is: HPC.hs
 70 |     build-depends:
 71 |         base -any,
 72 |         directory ==1.*,
 73 |         process ==1.*,
 74 |         regex-compat >=0.90
 75 |     default-language: Haskell2010
 76 |     hs-source-dirs: test-suite
 77 |     ghc-options: -Wall -Werror
 78 | test-suite documentation
 79 |     type: exitcode-stdio-1.0
 80 |     main-is: Haddock.hs
 81 |     build-depends:
 82 |         base -any,
 83 |         process -any,
 84 |         regex-compat -any
 85 |     default-language: Haskell2010
 86 |     hs-source-dirs: test-suite
 87 |     ghc-options: -Wall -Werror
 88 | test-suite style
 89 |     type: exitcode-stdio-1.0
 90 |     main-is: HLint.hs
 91 |     build-depends:
 92 |         base -any,
 93 |         hlint ==1.*
 94 |     default-language: Haskell2010
 95 |     hs-source-dirs: test-suite
 96 |     ghc-options: -Wall -Werror
 97 | 
 98 | benchmark benchmarks
 99 | 
100 |     if impl(ghc >=7.8)
101 |         build-depends:
102 |             criterion ==1.*
103 | 
104 |     if impl(ghc <7.8)
105 |         build-depends:
106 |             criterion ==0.6.*,
107 |             hastache <0.6,
108 |             statistics <0.11
109 |     type: exitcode-stdio-1.0
110 |     main-is: Bench.hs
111 |     build-depends:
112 |         base -any,
113 |         {{ProjectName}} -any
114 |     default-language: Haskell2010
115 |     hs-source-dirs: benchmark
116 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/README-HASKELETON.md:
--------------------------------------------------------------------------------
 1 | # [Haskeleton][1]
 2 | 
 3 | [![Build Status][2]][3]
 4 | 
 5 | Haskeleton is a project skeleton for Haskell packages. It's a tool,
 6 | like [`cabal init`][4], for creating new packages. Unlike `cabal
 7 | init`, packages created by Haskeleton are fully-featured and
 8 | idiomatic. Your new package will have:
 9 | 
10 | - A library with its own source directory and section in the Cabal
11 |   file.
12 | 
13 | - An executable that depends on your library.
14 | 
15 | - A comprehensive test suite including unit tests, property checks,
16 |   doctests, program and documentation coverage, and code quality.
17 | 
18 | - A benchmark suite for analyzing the peformance of your library.
19 | 
20 | For a more complete explanation of these features, read [Haskeleton's
21 | introductory blog post][5]. It also describes why you might want
22 | each of these things.
23 | 
24 | Haskeleton is implemented as a template for [`hi`][6]. To create a
25 | new package, run `hi` and point it to this repository. For example:
26 | 
27 | ``` sh
28 | $ hi example \
29 |     --repository git://github.com/tfausak/haskeleton.git
30 | Creating new project with git repository:git://github.com/tfausak/haskeleton.git
31 |     create  example/.gitattributes
32 |     create  example/.gitignore
33 |     create  example/.stylish-haskell.yaml
34 |     create  example/.travis.yml
35 |     create  example/CHANGELOG.md
36 |     create  example/CONTRIBUTING.md
37 |     create  example/HLint.hs
38 |     create  example/Haskeleton.hs
39 |     create  example/LICENSE.md
40 |     create  example/Makefile
41 |     create  example/README.md
42 |     create  example/Setup.hs
43 |     create  example/benchmark/Bench.hs
44 |     create  example/benchmark/ExampleBench.hs
45 |     create  example/executable/Main.hs
46 |     create  example/library/Example.hs
47 |     create  example/example.cabal
48 |     create  example/test-suite/DocTest.hs
49 |     create  example/test-suite/HLint.hs
50 |     create  example/test-suite/HPC.hs
51 |     create  example/test-suite/Haddock.hs
52 |     create  example/test-suite/ExampleSpec.hs
53 |     create  example/test-suite/Spec.hs
54 |     create  example/tmp/.gitignore
55 | ```
56 | 
57 | Haskeleton works with `hi` version 1.x. The packages it creates
58 | work with GHC 7.8 and 7.6, along with the latest version of the
59 | Haskell platform (2014.2.0.0).
60 | 
61 | [1]: http://taylor.fausak.me/haskeleton/
62 | [2]: https://img.shields.io/travis/tfausak/haskeleton/master.svg?label=build&style=flat-square
63 | [3]: https://travis-ci.org/tfausak/haskeleton
64 | [4]: https://www.haskell.org/cabal/users-guide/developing-packages.html#using-cabal-init
65 | [5]: http://taylor.fausak.me/2014/03/04/haskeleton-a-haskell-project-skeleton/
66 | [6]: https://github.com/fujimura/hi
67 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/README.md.template:
--------------------------------------------------------------------------------
 1 | # {{ProjectName}}
 2 | 
 3 | This is a new package created by [Haskeleton][]. To finish setting it up, look
 4 | for "TODO"s in the Cabal file and in the library itself. To quickly get up and
 5 | running, simply run `make`. See below for more detailed instructions.
 6 | 
 7 | [haskeleton]: http://taylor.fausak.me/haskeleton/
 8 | 
 9 | ``` sh
10 | # Update Cabal's list of packages.
11 | cabal update
12 | 
13 | # Initialize a sandbox and install the package's dependencies.
14 | make install
15 | 
16 | # Configure & build the package.
17 | make configure
18 | make build
19 | 
20 | # Test package.
21 | make test
22 | 
23 | # Benchmark package.
24 | make bench
25 | 
26 | # Run executable.
27 | make run
28 | 
29 | # Start REPL.
30 | make repl
31 | 
32 | # Generate documentation.
33 | make haddock
34 | 
35 | # Analyze coverage.
36 | make hpc
37 | ```
38 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/Setup.hs:
--------------------------------------------------------------------------------
1 | module Setup (main) where
2 | 
3 | import Distribution.Simple (defaultMain)
4 | 
5 | main :: IO ()
6 | main = defaultMain
7 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/benchmark/Bench.hs.template:
--------------------------------------------------------------------------------
 1 | module Main (main) where
 2 | 
 3 | import qualified {{ProjectName}}Bench
 4 | -- HASKELETON: import qualified New.ModuleBench
 5 | 
 6 | import Criterion.Main (bgroup, defaultMain)
 7 | 
 8 | main :: IO ()
 9 | main = defaultMain
10 |     [ bgroup "{{ProjectName}}" {{ProjectName}}Bench.benchmarks
11 |     -- HASKELETON: , bgroup "New.Module" New.ModuleBench.benchmarks
12 |     ]
13 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/benchmark/ProjectNameBench.hs.template:
--------------------------------------------------------------------------------
 1 | module {{ProjectName}}Bench (benchmarks) where
 2 | 
 3 | import {{ProjectName}}
 4 | 
 5 | import Criterion
 6 | 
 7 | benchmarks :: [Benchmark]
 8 | benchmarks =
 9 |     [ bench "main" (nfIO main)
10 |     ]
11 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/executable/Main.hs.template:
--------------------------------------------------------------------------------
1 | module Main (main) where
2 | 
3 | import qualified {{ProjectName}}
4 | 
5 | main :: IO ()
6 | main = {{ProjectName}}.main
7 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/library/ProjectName.hs.template:
--------------------------------------------------------------------------------
 1 | {-# OPTIONS_GHC -fno-warn-unused-imports #-}
 2 | 
 3 | -- | TODO
 4 | module {{ProjectName}} (module {{ProjectName}}) where
 5 | 
 6 | -- HASKELETON: import New.Module as {{ProjectName}}
 7 | 
 8 | -- | TODO
 9 | main :: IO ()
10 | main = return ()
11 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/test-suite/DocTest.hs:
--------------------------------------------------------------------------------
1 | module Main (main) where
2 | 
3 | import System.FilePath.Glob (glob)
4 | import Test.DocTest (doctest)
5 | 
6 | main :: IO ()
7 | main = glob "library/**/*.hs" >>= doctest
8 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/test-suite/HLint.hs:
--------------------------------------------------------------------------------
 1 | module Main (main) where
 2 | 
 3 | import Language.Haskell.HLint (hlint)
 4 | import System.Exit (exitFailure, exitSuccess)
 5 | 
 6 | arguments :: [String]
 7 | arguments =
 8 |     [ "benchmark"
 9 |     , "executable"
10 |     , "library"
11 |     , "test-suite"
12 |     ]
13 | 
14 | main :: IO ()
15 | main = do
16 |     hints <- hlint arguments
17 |     if null hints then exitSuccess else exitFailure
18 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/test-suite/HPC.hs:
--------------------------------------------------------------------------------
 1 | module Main (main) where
 2 | 
 3 | import Data.List (genericLength)
 4 | import Data.Maybe (catMaybes)
 5 | import System.Directory (doesFileExist)
 6 | import System.Exit (exitFailure, exitSuccess)
 7 | import System.Process (readProcess)
 8 | import Text.Regex (matchRegex, mkRegex)
 9 | 
10 | average :: (Fractional a, Real b) => [b] -> a
11 | average xs = realToFrac (sum xs) / genericLength xs
12 | 
13 | expected :: Fractional a => a
14 | expected = 90
15 | 
16 | main :: IO ()
17 | main = do
18 |     file <- tix
19 |     let arguments = ["report", file]
20 | 
21 |     output <- readProcess "hpc" arguments ""
22 |     if average (match output) >= (expected :: Float)
23 |         then exitSuccess
24 |         else putStr output >> exitFailure
25 | 
26 | match :: String -> [Int]
27 | match = fmap read . concat . catMaybes . fmap (matchRegex pattern) . lines
28 |   where
29 |     pattern = mkRegex "^ *([0-9]*)% "
30 | 
31 | -- The location of the TIX file changed between versions of cabal-install.
32 | -- See <https://github.com/tfausak/haskeleton/issues/31> for details.
33 | tix :: IO FilePath
34 | tix = do
35 |     let newFile = "tests.tix"
36 |         oldFile = "dist/hpc/tix/tests/tests.tix"
37 |     newFileExists <- doesFileExist newFile
38 |     let file = if newFileExists then newFile else oldFile
39 |     return file
40 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/test-suite/Haddock.hs:
--------------------------------------------------------------------------------
 1 | module Main (main) where
 2 | 
 3 | import Data.List (genericLength)
 4 | import Data.Maybe (catMaybes)
 5 | import System.Exit (exitFailure, exitSuccess)
 6 | import System.Process (readProcess)
 7 | import Text.Regex (matchRegex, mkRegex)
 8 | 
 9 | arguments :: [String]
10 | arguments =
11 |     [ "haddock"
12 |     ]
13 | 
14 | average :: (Fractional a, Real b) => [b] -> a
15 | average xs = realToFrac (sum xs) / genericLength xs
16 | 
17 | expected :: Fractional a => a
18 | expected = 90
19 | 
20 | main :: IO ()
21 | main = do
22 |     output <- readProcess "cabal" arguments ""
23 |     if average (match output) >= (expected :: Float)
24 |         then exitSuccess
25 |         else putStr output >> exitFailure
26 | 
27 | match :: String -> [Int]
28 | match = fmap read . concat . catMaybes . fmap (matchRegex pattern) . lines
29 |   where
30 |     pattern = mkRegex "^ *([0-9]*)% "
31 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/test-suite/ProjectNameSpec.hs.template:
--------------------------------------------------------------------------------
 1 | module {{ProjectName}}Spec (spec) where
 2 | 
 3 | import {{ProjectName}}
 4 | 
 5 | import Test.Hspec
 6 | 
 7 | spec :: Spec
 8 | spec =
 9 |     describe "main" $$ do
10 |         it "returns the unit" $$
11 |             main `shouldReturn` ()
12 | 


--------------------------------------------------------------------------------
/devrepo/haskeleton/test-suite/Spec.hs:
--------------------------------------------------------------------------------
1 | {-# OPTIONS_GHC -F -pgmF hspec-discover #-}
2 | 


--------------------------------------------------------------------------------
/devrepo/servant.tar.metainfo:
--------------------------------------------------------------------------------
1 | servant -- [new project] scaffolding for web-service with Servant
2 | 
3 | Create project like this:
4 | 
5 | $ trurl new project MyProj servant
6 | 
7 | Use mysql.sql to create a database for the generated project.


--------------------------------------------------------------------------------
/devrepo/servant/.projectile:
--------------------------------------------------------------------------------
1 | -.stack-work/


--------------------------------------------------------------------------------
/devrepo/servant/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright Author name here (c) 2015
 2 | 
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are met:
 7 | 
 8 |     * Redistributions of source code must retain the above copyright
 9 |       notice, this list of conditions and the following disclaimer.
10 | 
11 |     * Redistributions in binary form must reproduce the above
12 |       copyright notice, this list of conditions and the following
13 |       disclaimer in the documentation and/or other materials provided
14 |       with the distribution.
15 | 
16 |     * Neither the name of Author name here nor the names of other
17 |       contributors may be used to endorse or promote products derived
18 |       from this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


--------------------------------------------------------------------------------
/devrepo/servant/ProjectName.cabal.template:
--------------------------------------------------------------------------------
 1 | name:                {{ProjectName}}
 2 | version:             0.1.0.0
 3 | synopsis:            Initial project template from stack
 4 | description:         Please see README.md
 5 | homepage:            http://github.com/githubuser/{{ProjectName}}#readme
 6 | license:             BSD3
 7 | license-file:        LICENSE
 8 | author:              Author name here
 9 | maintainer:          example@example.com
10 | copyright:           2010 Author Here
11 | category:            Web
12 | build-type:          Simple
13 | -- extra-source-files:
14 | cabal-version:       >=1.10
15 | 
16 | library
17 |   hs-source-dirs:      src
18 |   exposed-modules:     Lib
19 |                      , Auth.AuthHeader
20 |                      , Auth.DbAuth
21 |                      , AppConfig
22 |                      , Db.Common                     
23 |                      , Json.User
24 |                      , Db.User
25 |                      , Convert.UserConverter
26 |                      
27 |                      
28 |   build-depends:       base >= 4.7 && < 5
29 |                      , HTTP
30 |                      , word8
31 |                      , aeson
32 |                      , base64-bytestring
33 |                      , bytestring
34 |                      , configurator
35 |                      , http-types
36 |                      , mysql
37 |                      , persistent
38 |                      , persistent-template
39 |                      , persistent-mysql
40 |                      , resource-pool
41 |                      , text
42 |                      , utf8-string
43 |                      , wai
44 |                      , wai-middleware-static
45 |                      , wai-extra
46 |                      , warp
47 |                      , monad-logger
48 |                      , MissingH
49 |                      , transformers
50 |                      , servant
51 |                      , servant-server
52 |                      , either
53 |   
54 |   default-language:    Haskell2010
55 | 
56 | executable {{ProjectName}}-exe
57 |   hs-source-dirs:      app
58 |   main-is:             Main.hs
59 |   ghc-options:         -threaded -rtsopts -with-rtsopts=-N
60 |   build-depends:       base
61 |                      , {{ProjectName}}                     
62 |   default-language:    Haskell2010
63 | 
64 | test-suite {{ProjectName}}-test
65 |   type:                exitcode-stdio-1.0
66 |   hs-source-dirs:      test
67 |   main-is:             Spec.hs
68 |   build-depends:       base
69 |                      , {{ProjectName}}
70 |   ghc-options:         -threaded -rtsopts -with-rtsopts=-N
71 |   default-language:    Haskell2010
72 | 
73 | source-repository head
74 |   type:     git
75 |   location: https://github.com/githubuser/{{ProjectName}}
76 | 


--------------------------------------------------------------------------------
/devrepo/servant/Setup.hs:
--------------------------------------------------------------------------------
1 | import Distribution.Simple
2 | main = defaultMain
3 | 


--------------------------------------------------------------------------------
/devrepo/servant/app/Main.hs:
--------------------------------------------------------------------------------
1 | module Main where
2 | 
3 | import Lib
4 | 
5 | main :: IO ()
6 | main = mainFunc
7 | 


--------------------------------------------------------------------------------
/devrepo/servant/application.conf.template:
--------------------------------------------------------------------------------
 1 | database {
 2 |   name = "{{ProjectName}}"
 3 |   user = "{{ProjectName}}"
 4 |   password = "{{ProjectName}}"
 5 |   host = "localhost"
 6 |   port = 3306
 7 |   salt = "my-salt-123"
 8 | }
 9 | 
10 | application {
11 |   port = 3000
12 |   poolSize = 10
13 | }


--------------------------------------------------------------------------------
/devrepo/servant/mysql.sql.template:
--------------------------------------------------------------------------------
 1 | create database {{ProjectName}};
 2 | grant all on {{ProjectName}}.* on {{ProjectName}}@localhost identified by '{{ProjectName}}';
 3 | 
 4 | flush privileges;
 5 | 
 6 | use {{ProjectName}};
 7 | create table `user` (id int auto_increment primary key, login varchar(128) unique not null, password varchar(128) not null);
 8 | 
 9 | -- The `user` table contains one user with login 'user' and password 'password'
10 | insert into `user`(`login`, `password`) values('user', md5('my-salt-123password'));
11 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/AppConfig.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | {-# LANGUAGE DeriveGeneric #-}
 3 | 
 4 | module AppConfig where
 5 | 
 6 | import GHC.Generics (Generic)
 7 | import qualified Data.Configurator as C
 8 | import qualified Data.Configurator.Types as C
 9 | import Data.Word
10 | 
11 | data AppConfig = AppConfig {
12 |        dbName     :: String
13 |      , dbUser     :: String
14 |      , dbPassword :: String
15 |      , dbSalt     :: String
16 |      , dbHost     :: String
17 |      , dbPort     :: Word16
18 |      , appPort    :: Word16
19 |      , poolSize   :: Word16
20 |      }
21 |      deriving (Show, Generic)
22 | 
23 | makeDbConfig :: C.Config -> IO (Maybe AppConfig)
24 | makeDbConfig conf = do
25 |   name     <- C.lookup conf "database.name"         :: IO (Maybe String)
26 |   user     <- C.lookup conf "database.user"         :: IO (Maybe String)
27 |   password <- C.lookup conf "database.password"     :: IO (Maybe String)
28 |   dsalt    <- C.lookup conf "database.salt"         :: IO (Maybe String)
29 |   host     <- C.lookup conf "database.host"         :: IO (Maybe String)
30 |   dport    <- C.lookup conf "database.port"         :: IO (Maybe Word16)
31 |   port     <- C.lookup conf "application.port"      :: IO (Maybe Word16)
32 |   psize    <- C.lookup conf "application.poolSize"  :: IO (Maybe Word16)
33 |   return $ AppConfig <$> name
34 |                      <*> user
35 |                      <*> password
36 |                      <*> dsalt
37 |                      <*> host
38 |                      <*> dport
39 |                      <*> port
40 |                      <*> psize
41 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/Auth/AuthHeader.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE TupleSections #-}
 2 | {-# LANGUAGE OverloadedStrings #-}
 3 | 
 4 | module Auth.AuthHeader where
 5 | 
 6 | import Network.Wai
 7 | import Network.Wai.Handler.Warp
 8 | import Data.ByteString.Base64 (decodeLenient)
 9 | import qualified Data.Text as T
10 | import qualified Data.Text.Encoding as T8
11 | import qualified Data.ByteString as B
12 | import qualified Data.ByteString.Char8 as C
13 | import Data.Word8 (isSpace, _colon, toLower)
14 | import Data.Hash.MD5
15 | 
16 | extractBasicAuth :: T.Text -> Maybe (T.Text, T.Text)
17 | extractBasicAuth bs =
18 |   let (x, y) = B.break isSpace $ T8.encodeUtf8 bs
19 |   in if B.map toLower x == "basic"
20 |      then decode $ extract $ B.dropWhile isSpace y
21 |      else Nothing
22 |   where extract encoded =
23 |             let rawstr = decodeLenient encoded
24 |                 (username, password') = B.break (== _colon) rawstr
25 |             in ((username,) . snd) <$> B.uncons password'
26 |         decode Nothing = Nothing
27 |         decode (Just (u,p)) = Just (T8.decodeUtf8 u, T8.decodeUtf8 p)
28 | 
29 | encodePassword :: String -> String -> String
30 | encodePassword salt pwd = md5s $ Str $ salt ++ pwd
31 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/Auth/DbAuth.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | module Auth.DbAuth where
 3 | 
 4 | import Data.Text
 5 | import Database.Persist.MySQL
 6 | import Database.Persist.Sql
 7 | import Control.Monad.IO.Class
 8 | import Control.Monad.Trans.Either
 9 | import Servant.API
10 | import Servant
11 | 
12 | import Auth.AuthHeader
13 | 
14 | import Db.Common
15 | import qualified Db.User as Db
16 | import qualified Json.User as J
17 | import qualified Convert.UserConverter as C
18 | 
19 | findUser :: ConnectionPool -> Text -> Text -> String -> IO (Maybe J.User)
20 | findUser pool login password salt = do
21 |      users <- flip runSqlPool pool $
22 |                        selectList [Db.UserLogin ==. unpack login, Db.UserPassword ==. encodePassword salt (unpack password)] []
23 |      return $ oneUser users
24 |      
25 |      where oneUser [user] = C.toJson user
26 |            oneUser _ = Nothing
27 | 
28 | 
29 | authHeaderToUser :: MonadIO m => ConnectionPool -> Text -> String -> m (Maybe J.User)
30 | authHeaderToUser pool authHeader salt = do
31 |     let auth = extractBasicAuth authHeader
32 |     liftIO $ tryFindUser auth
33 | 
34 |     where tryFindUser Nothing = return Nothing
35 |           tryFindUser (Just (login, password)) = findUser pool login password salt
36 | 
37 | withUser :: ConnectionPool -> Text -> String -> (J.User -> EitherT ServantErr IO a) -> EitherT ServantErr IO a
38 | withUser pool authHeader salt func = do
39 |     maybeUser <- authHeaderToUser pool authHeader salt
40 |     case maybeUser of
41 |         Nothing -> left $ err403 { errBody = "No user found!" }
42 |         Just user -> func user
43 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/Convert/UserConverter.hs:
--------------------------------------------------------------------------------
 1 | module Convert.UserConverter where
 2 | 
 3 | import Prelude hiding (id)
 4 | import GHC.Generics (Generic)
 5 | import qualified Data.Aeson as A
 6 | 
 7 | import Database.Persist.MySQL
 8 | import Data.Text
 9 | 
10 | import Db.Common
11 | import qualified Db.User as D
12 | import Json.User
13 | 
14 | 
15 | toEntity (User maybeId _login _password) =
16 |     case maybeId of
17 |         Nothing -> Nothing
18 |         Just _id -> Just $ Entity (toSqlKey (fromIntegral _id) :: Key D.User) $
19 |                                 D.User _login _password
20 | 
21 | toRecord (User _ _login _password) = D.User _login _password
22 | 
23 | toJson (Entity key (D.User _login _password)) =
24 |     let vals = keyToValues key
25 |     in processKeys vals
26 |     
27 |     where processKeys [pval] =
28 |             let eitherId = fromPersistValue pval :: Either Text Int
29 |             in case eitherId of
30 |                 Left _ -> Nothing
31 |                 Right _id -> Just $ User (Just $ fromIntegral _id) _login _password
32 |                 
33 |           processKeys _ = Nothing
34 | 
35 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/Db/Common.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE FlexibleContexts #-}
 2 | module Db.Common where
 3 | 
 4 | import Control.Monad.IO.Class
 5 | import Database.Persist.MySQL
 6 | 
 7 | query :: MonadIO m => ConnectionPool -> SqlPersistT IO a -> m a
 8 | query pool query = liftIO $ runSqlPool query pool
 9 | 
10 | toKey :: ToBackendKey SqlBackend record => Int -> Key record
11 | toKey _id = toSqlKey $ fromIntegral _id
12 | 
13 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/Db/User.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE GADTs                      #-}
 2 | {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 3 | {-# LANGUAGE MultiParamTypeClasses      #-}
 4 | {-# LANGUAGE QuasiQuotes                #-}
 5 | {-# LANGUAGE TemplateHaskell            #-}
 6 | {-# LANGUAGE TypeFamilies               #-}
 7 | {-# LANGUAGE DeriveGeneric              #-}
 8 | 
 9 | module Db.User where
10 | 
11 | import GHC.Generics
12 | import Database.Persist.TH
13 | import Database.Persist
14 | import Database.Persist.Sql
15 | 
16 | share [mkPersist sqlSettings] [persistLowerCase|
17 | User
18 |     login    String
19 |     password String
20 |     deriving Show
21 |     deriving Generic
22 | |]
23 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/Json/User.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE DeriveGeneric #-}
 2 | 
 3 | module Json.User where
 4 | 
 5 | import GHC.Generics (Generic)
 6 | import qualified Data.Aeson as A
 7 | 
 8 | data User = User {
 9 |     id       :: Maybe Int
10 |   , login    :: String
11 |   , password :: String
12 |   }
13 |   deriving (Show, Generic)
14 | 
15 | instance A.ToJSON User
16 | instance A.FromJSON User
17 | 


--------------------------------------------------------------------------------
/devrepo/servant/src/Lib.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE DataKinds         #-}
 2 | {-# LANGUAGE OverloadedStrings #-}
 3 | {-# LANGUAGE TypeFamilies      #-}
 4 | {-# LANGUAGE TypeOperators     #-}
 5 | 
 6 | module Lib
 7 |     ( mainFunc
 8 |     ) where
 9 | 
10 | import Network.Wai.Handler.Warp
11 | import qualified Data.Configurator as C
12 | import Data.Text
13 | import Servant
14 | 
15 | import Database.Persist.MySQL
16 | import Control.Monad.Logger
17 | 
18 | import Auth.AuthHeader
19 | import Auth.DbAuth
20 | import AppConfig
21 | import Db.Common
22 | 
23 | 
24 | import Control.Monad.IO.Class
25 | import Control.Monad.Trans.Either
26 | 
27 | 
28 | configFileName :: String
29 | configFileName = "application.conf"
30 | 
31 | 
32 | connectInfo :: AppConfig -> ConnectInfo
33 | connectInfo conf = defaultConnectInfo { connectUser = dbUser conf
34 |                                       , connectPassword = dbPassword conf
35 |                                       , connectDatabase = dbName conf
36 |                                       , connectHost = dbHost conf
37 |                                       , connectPort = dbPort conf
38 |                                       }
39 | 
40 | ---------------------------------------
41 | -- Examples section
42 | 
43 | helloUser :: ConnectionPool -> String -> Maybe Text -> EitherT ServantErr IO Text
44 | helloUser pool salt Nothing = left $ err403 { errBody = "No Authorization header found!" }
45 | helloUser pool salt (Just authHeader) =
46 |     withUser pool authHeader salt $ \user -> do
47 |         liftIO $ print user
48 |         return $ pack $ show user
49 | 
50 | hello :: EitherT ServantErr IO Text
51 | hello  = return "Hello, World!"
52 | 
53 | ---------------------------------------
54 | 
55 | type API = "helloUser" :> Header "Authorization" Text :> Get '[PlainText] Text
56 |       :<|> "hello" :> Get '[PlainText] Text
57 | 
58 | type API' = API :<|> Raw
59 | 
60 | 
61 | api :: Proxy API
62 | api = Proxy
63 | 
64 | api' :: Proxy API'
65 | api' = Proxy
66 | 
67 | server :: ConnectionPool -> String -> Server API
68 | server pool salt = helloUser pool salt
69 |               :<|> hello
70 | 
71 | server' :: ConnectionPool -> String -> Server API'
72 | server' pool salt = server pool salt
73 |                :<|> serveDirectory "static"
74 | 
75 | 
76 | ---------------------------------------
77 | 
78 | mainFunc :: IO ()
79 | mainFunc = do
80 |     putStrLn "Starting server..."
81 |     loadedConf <- C.load [C.Required configFileName]
82 |     maybeConf <- makeDbConfig loadedConf
83 |     case maybeConf of
84 |         Nothing -> putStrLn $ "Can't parse \"" ++ configFileName ++ "\" file, terminating!"
85 |         Just conf -> do
86 |             pool <- runStdoutLoggingT $ createMySQLPool (connectInfo conf) (fromIntegral $ poolSize conf)
87 |             run (fromIntegral $ appPort conf) (serve api' (server' pool (dbSalt conf)))
88 | 


--------------------------------------------------------------------------------
/devrepo/servant/stack.yaml:
--------------------------------------------------------------------------------
 1 | # For more information, see: https://github.com/commercialhaskell/stack/blob/release/doc/yaml_configuration.md
 2 | 
 3 | # Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
 4 | resolver: lts-3.11
 5 | 
 6 | # Local packages, usually specified by relative directory name
 7 | packages:
 8 | - '.'
 9 | 
10 | # Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
11 | extra-deps: []
12 | 
13 | # Override default flag values for local packages and extra-deps
14 | flags: {}
15 | 
16 | # Extra package databases containing global packages
17 | extra-package-dbs: []
18 | 
19 | # Control whether we use the GHC we find on the path
20 | # system-ghc: true
21 | 
22 | # Require a specific version of stack, using version ranges
23 | # require-stack-version: -any # Default
24 | # require-stack-version: >= 0.1.4.0
25 | 
26 | # Override the architecture used by stack, especially useful on Windows
27 | # arch: i386
28 | # arch: x86_64
29 | 
30 | # Extra directories used by stack for building
31 | # extra-include-dirs: [/path/to/dir]
32 | # extra-lib-dirs: [/path/to/dir]
33 | 


--------------------------------------------------------------------------------
/devrepo/servant/test/Spec.hs:
--------------------------------------------------------------------------------
1 | main :: IO ()
2 | main = putStrLn "Test suite not yet implemented"
3 | 


--------------------------------------------------------------------------------
/devrepo/srv-converter:
--------------------------------------------------------------------------------
 1 | module Convert.{{entity}}Converter where
 2 | 
 3 | import Prelude hiding (id)
 4 | import GHC.Generics (Generic)
 5 | import qualified Data.Aeson as A
 6 | 
 7 | import Database.Persist.MySQL
 8 | import Data.Text
 9 | 
10 | import Db.Common
11 | import qualified Db.{{entity}} as D
12 | import Json.{{entity}}
13 | 
14 | toEntity :: {{entity}} -> Maybe (Entity D.{{entity}})
15 | toEntity domEntity =
16 |     case id domEntity of
17 |         Nothing -> Nothing
18 |         Just _id -> Just $ Entity (toSqlKey (fromIntegral _id) :: Key D.{{entity}}) $ toRecord domEntity
19 | 
20 | toRecord :: {{entity}} -> D.{{entity}}
21 | toRecord ({{entity}} _id{{#fields}} _{{key}}{{/fields}}) = D.{{entity}}{{#fields}} _{{key}}{{/fields}}
22 | 
23 | toJson :: Entity D.{{entity}} -> Maybe {{entity}}
24 | toJson (Entity key (D.{{entity}}{{#fields}} _{{key}}{{/fields}})) =
25 |     let vals = keyToValues key
26 |     in processKeys vals
27 |     
28 |     where processKeys [pval] =
29 |             let eitherId = fromPersistValue pval :: Either Text Int
30 |             in case eitherId of
31 |                 Left _ -> Nothing
32 |                 Right _id -> Just $ {{entity}} (Just $ fromIntegral _id){{#fields}} _{{key}}{{/fields}}
33 |           processKeys _ = Nothing
34 | 
35 | 


--------------------------------------------------------------------------------
/devrepo/srv-converter.metainfo:
--------------------------------------------------------------------------------
1 | srv-converter -- [new file] converter of json entity to persistent entity and vice versa
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/devrepo/srv-crud:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE DataKinds         #-}
 2 | {-# LANGUAGE OverloadedStrings #-}
 3 | {-# LANGUAGE TypeFamilies      #-}
 4 | {-# LANGUAGE TypeOperators     #-}
 5 | 
 6 | module Logic.{{entity}} where
 7 | 
 8 | import Database.Persist.MySQL
 9 | import Servant
10 | import Control.Monad.Trans.Either
11 | import Control.Monad.IO.Class
12 | import Data.Text hiding (replace, length, any, concat, map, filter)
13 | import Data.Char
14 | import Data.Maybe
15 | import Data.Word
16 | 
17 | import Auth.DbAuth
18 | import Db.Common
19 | import Json.{{entity}} ({{entity}}(..))
20 | import qualified Json.{{entity}} as Json{{entity}}
21 | import qualified Db.{{entity}} as Db{{entity}}
22 | import Json.User (User(..))
23 | import qualified Json.User as JsonUser
24 | import qualified Convert.{{entity}}Converter as C
25 | 
26 | 
27 | create{{entity}} :: ConnectionPool -> String -> Maybe Text -> {{entity}} -> EitherT ServantErr IO ()
28 | create{{entity}} _ _ Nothing _ = return ()
29 | create{{entity}} pool salt (Just authHeader) entity =
30 |     withUser pool authHeader salt $ \user -> do
31 |         query pool $ insert (C.toRecord entity {user_id = JsonUser.id user} :: Db{{entity}}.{{entity}})
32 |         return ()
33 | 
34 | entityBelongsToUser :: MonadIO m => ConnectionPool -> User -> Int -> m Bool
35 | entityBelongsToUser _ (User {JsonUser.id = Nothing}) _ = return False -- No user id
36 | entityBelongsToUser pool (User {JsonUser.id = _id}) _bid = do
37 |     entitys <- query pool $ selectList [Db{{entity}}.{{entity}}User_id ==. _id, Db{{entity}}.{{entity}}Id ==. toKey _bid] []
38 |     return $ length entitys == 1
39 | 
40 | update{{entity}} :: ConnectionPool -> String -> Maybe Text -> {{entity}} -> EitherT ServantErr IO ()
41 | update{{entity}} _ _ Nothing _ = return ()
42 | update{{entity}} pool salt (Just authHeader) entity =
43 |     withUser pool authHeader salt $ \user ->
44 |         case entity of
45 |             {{entity}} {Json{{entity}}.id = Nothing} -> left $ err400 { errBody = "No id specified!" }
46 |             {{entity}} {Json{{entity}}.id = Just _id} -> do
47 |                 belongs <- entityBelongsToUser pool user _id
48 |                 if belongs
49 |                     then do
50 |                         query pool $ replace (toKey _id :: Key Db{{entity}}.{{entity}})
51 |                                              (C.toRecord entity {user_id = JsonUser.id user} :: Db{{entity}}.{{entity}})
52 |                         return ()
53 |                     else return ()
54 | 
55 | delete{{entity}} :: ConnectionPool -> String -> Maybe Text -> Int -> EitherT ServantErr IO ()
56 | delete{{entity}} _ _ Nothing _ = return ()
57 | delete{{entity}} pool salt (Just authHeader) _id =
58 |     withUser pool authHeader salt $ \user -> do
59 |         belongs <- entityBelongsToUser pool user _id
60 |         if belongs
61 |             then do
62 |                 query pool $ delete (toKey _id :: Key Db{{entity}}.{{entity}})
63 |                 return ()
64 |             else return ()
65 |         
66 | 
67 | show{{entity}} :: ConnectionPool -> Int -> EitherT ServantErr IO (Maybe {{entity}})
68 | show{{entity}} pool id = do
69 |     entity <- query pool $ selectFirst [Db{{entity}}.{{entity}}Id ==. (toKey id :: Key Db{{entity}}.{{entity}})] []
70 |     return $ maybe{{entity}} entity
71 |     where maybe{{entity}} Nothing = Nothing
72 |           maybe{{entity}} (Just b) = C.toJson b
73 | 
74 | 
75 | select{{entity}}s :: ConnectionPool -> Maybe String -> Maybe String -> Maybe Word16 -> Maybe Word16 -> EitherT ServantErr IO [{{entity}}]
76 | select{{entity}}s _ Nothing _ _ _= return []
77 | select{{entity}}s _ _ Nothing _ _ = return []
78 | select{{entity}}s _ _ _ Nothing _ = return []
79 | select{{entity}}s _ _ _ _ Nothing = return []
80 | select{{entity}}s pool (Just field) (Just searchStr) (Just offset) (Just limit) = do
81 |     let entityField = case field of
82 |                         "title" -> Db{{entity}}.{{entity}}Title
83 |                         "author" -> Db{{entity}}.{{entity}}Author
84 |                         "content" -> Db{{entity}}.{{entity}}Content
85 |     if any (not . isAlphaNum) searchStr
86 |         then return []
87 |         else do
88 |             entitys <- query pool $ selectList [Filter entityField (Left $ concat ["%", searchStr, "%"]) (BackendSpecificFilter "like")]
89 |                                             [OffsetBy $ fromIntegral offset, LimitTo $ fromIntegral limit]
90 |             return $ map (\(Just b) -> b) $ filter isJust $ map C.toJson entitys
91 | 


--------------------------------------------------------------------------------
/devrepo/srv-crud.metainfo:
--------------------------------------------------------------------------------
1 | srv-crud -- [new file] crud operations for user dependent db entity
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/devrepo/srv-db-entity:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE GADTs                      #-}
 2 | {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 3 | {-# LANGUAGE MultiParamTypeClasses      #-}
 4 | {-# LANGUAGE QuasiQuotes                #-}
 5 | {-# LANGUAGE TemplateHaskell            #-}
 6 | {-# LANGUAGE TypeFamilies               #-}
 7 | {-# LANGUAGE DeriveGeneric              #-}
 8 | 
 9 | module Db.{{entity}} where
10 | 
11 | import GHC.Generics
12 | import Database.Persist.TH
13 | import Database.Persist
14 | import Database.Persist.Sql
15 | 
16 | share [mkPersist sqlSettings] [persistLowerCase|
17 | {{entity}}
18 | {{#fields}}
19 |     {{key}} {{value}}
20 | {{/fields}}    
21 |     deriving Eq
22 |     deriving Show
23 |     deriving Generic
24 | |]
25 | 
26 | 


--------------------------------------------------------------------------------
/devrepo/srv-db-entity.metainfo:
--------------------------------------------------------------------------------
1 | srv-db-entity -- [new file] generate persistent entity
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/devrepo/srv-json-entity:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | {-# LANGUAGE DeriveGeneric #-}
 3 | 
 4 | module Json.{{entity}} where
 5 | 
 6 | import GHC.Generics (Generic)
 7 | import qualified Data.Aeson as A
 8 | 
 9 | data {{entity}} = {{entity}} {
10 |     id       :: Maybe Int
11 | {{#fields}}
12 |   , {{key}} :: {{value}}
13 | {{/fields}}
14 |   }
15 |   deriving (Show, Generic)
16 | 
17 | instance A.ToJSON {{entity}}
18 | instance A.FromJSON {{entity}}
19 | 


--------------------------------------------------------------------------------
/devrepo/srv-json-entity.metainfo:
--------------------------------------------------------------------------------
1 | srv-json-entity -- [new file] generate json entity
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/img/trurl.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dbushenko/trurl/2ded67e3121ae3feaa3a63a7813a9ddb50e13d71/img/trurl.jpg


--------------------------------------------------------------------------------
/repository/registry.json:
--------------------------------------------------------------------------------
 1 | [ { "url": "https://github.com/dbushenko/trurl/raw/master/repository/templates/"
 2 |   , "templateName": "haskeleton.tar"
 3 |   },
 4 |   
 5 |   { "url": "https://github.com/dbushenko/trurl/raw/master/repository/templates/"
 6 |   , "templateName": "servant.tar"
 7 |   },
 8 |   
 9 |   { "url": "https://github.com/dbushenko/trurl/raw/master/repository/templates/"
10 |   , "templateName": "srv-json-entity"
11 |   },
12 |   
13 |   { "url": "https://github.com/dbushenko/trurl/raw/master/repository/templates/"
14 |   , "templateName": "srv-db-entity"
15 |   },
16 |   
17 |   { "url": "https://github.com/dbushenko/trurl/raw/master/repository/templates/"
18 |   , "templateName": "srv-converter"
19 |   },
20 |   
21 |   { "url": "https://github.com/dbushenko/trurl/raw/master/repository/templates/"
22 |   , "templateName": "srv-crud"
23 |   }  
24 | ]
25 | 


--------------------------------------------------------------------------------
/repository/templates/haskeleton.tar:
--------------------------------------------------------------------------------
  1 | benchmark/0000755000175000017500000000000012540312311011104 5ustar  dimdimbenchmark/Bench.hs.template0000644000175000017500000000051012540312267014277 0ustar  dimdimmodule Main (main) where
  2 | 
  3 | import qualified {{ProjectName}}Bench
  4 | -- HASKELETON: import qualified New.ModuleBench
  5 | 
  6 | import Criterion.Main (bgroup, defaultMain)
  7 | 
  8 | main :: IO ()
  9 | main = defaultMain
 10 |     [ bgroup "{{ProjectName}}" {{ProjectName}}Bench.benchmarks
 11 |     -- HASKELETON: , bgroup "New.Module" New.ModuleBench.benchmarks
 12 |     ]
 13 | benchmark/ProjectNameBench.hs.template0000644000175000017500000000024612540312311016423 0ustar  dimdimmodule {{ProjectName}}Bench (benchmarks) where
 14 | 
 15 | import {{ProjectName}}
 16 | 
 17 | import Criterion
 18 | 
 19 | benchmarks :: [Benchmark]
 20 | benchmarks =
 21 |     [ bench "main" (nfIO main)
 22 |     ]
 23 | executable/0000755000175000017500000000000012540312327011302 5ustar  dimdimexecutable/Main.hs.template0000644000175000017500000000014612540312327014335 0ustar  dimdimmodule Main (main) where
 24 | 
 25 | import qualified {{ProjectName}}
 26 | 
 27 | main :: IO ()
 28 | main = {{ProjectName}}.main
 29 | library/0000755000175000017500000000000012540312346010626 5ustar  dimdimlibrary/ProjectName.hs.template0000644000175000017500000000031512540312346015202 0ustar  dimdim{-# OPTIONS_GHC -fno-warn-unused-imports #-}
 30 | 
 31 | -- | TODO
 32 | module {{ProjectName}} (module {{ProjectName}}) where
 33 | 
 34 | -- HASKELETON: import New.Module as {{ProjectName}}
 35 | 
 36 | -- | TODO
 37 | main :: IO ()
 38 | main = return ()
 39 | test-suite/0000755000175000017500000000000012540312366011272 5ustar  dimdimtest-suite/Spec.hs0000644000175000017500000000005412524653750012526 0ustar  dimdim{-# OPTIONS_GHC -F -pgmF hspec-discover #-}
 40 | test-suite/HPC.hs0000644000175000017500000000220412524653750012245 0ustar  dimdimmodule Main (main) where
 41 | 
 42 | import Data.List (genericLength)
 43 | import Data.Maybe (catMaybes)
 44 | import System.Directory (doesFileExist)
 45 | import System.Exit (exitFailure, exitSuccess)
 46 | import System.Process (readProcess)
 47 | import Text.Regex (matchRegex, mkRegex)
 48 | 
 49 | average :: (Fractional a, Real b) => [b] -> a
 50 | average xs = realToFrac (sum xs) / genericLength xs
 51 | 
 52 | expected :: Fractional a => a
 53 | expected = 90
 54 | 
 55 | main :: IO ()
 56 | main = do
 57 |     file <- tix
 58 |     let arguments = ["report", file]
 59 | 
 60 |     output <- readProcess "hpc" arguments ""
 61 |     if average (match output) >= (expected :: Float)
 62 |         then exitSuccess
 63 |         else putStr output >> exitFailure
 64 | 
 65 | match :: String -> [Int]
 66 | match = fmap read . concat . catMaybes . fmap (matchRegex pattern) . lines
 67 |   where
 68 |     pattern = mkRegex "^ *([0-9]*)% "
 69 | 
 70 | -- The location of the TIX file changed between versions of cabal-install.
 71 | -- See <https://github.com/tfausak/haskeleton/issues/31> for details.
 72 | tix :: IO FilePath
 73 | tix = do
 74 |     let newFile = "tests.tix"
 75 |         oldFile = "dist/hpc/tix/tests/tests.tix"
 76 |     newFileExists <- doesFileExist newFile
 77 |     let file = if newFileExists then newFile else oldFile
 78 |     return file
 79 | test-suite/Haddock.hs0000644000175000017500000000135712524653750013200 0ustar  dimdimmodule Main (main) where
 80 | 
 81 | import Data.List (genericLength)
 82 | import Data.Maybe (catMaybes)
 83 | import System.Exit (exitFailure, exitSuccess)
 84 | import System.Process (readProcess)
 85 | import Text.Regex (matchRegex, mkRegex)
 86 | 
 87 | arguments :: [String]
 88 | arguments =
 89 |     [ "haddock"
 90 |     ]
 91 | 
 92 | average :: (Fractional a, Real b) => [b] -> a
 93 | average xs = realToFrac (sum xs) / genericLength xs
 94 | 
 95 | expected :: Fractional a => a
 96 | expected = 90
 97 | 
 98 | main :: IO ()
 99 | main = do
100 |     output <- readProcess "cabal" arguments ""
101 |     if average (match output) >= (expected :: Float)
102 |         then exitSuccess
103 |         else putStr output >> exitFailure
104 | 
105 | match :: String -> [Int]
106 | match = fmap read . concat . catMaybes . fmap (matchRegex pattern) . lines
107 |   where
108 |     pattern = mkRegex "^ *([0-9]*)% "
109 | test-suite/HLint.hs0000644000175000017500000000051112524653750012650 0ustar  dimdimmodule Main (main) where
110 | 
111 | import Language.Haskell.HLint (hlint)
112 | import System.Exit (exitFailure, exitSuccess)
113 | 
114 | arguments :: [String]
115 | arguments =
116 |     [ "benchmark"
117 |     , "executable"
118 |     , "library"
119 |     , "test-suite"
120 |     ]
121 | 
122 | main :: IO ()
123 | main = do
124 |     hints <- hlint arguments
125 |     if null hints then exitSuccess else exitFailure
126 | test-suite/DocTest.hs0000644000175000017500000000022412524653750013200 0ustar  dimdimmodule Main (main) where
127 | 
128 | import System.FilePath.Glob (glob)
129 | import Test.DocTest (doctest)
130 | 
131 | main :: IO ()
132 | main = glob "library/**/*.hs" >>= doctest
133 | test-suite/ProjectNameSpec.hs.template0000644000175000017500000000030612540312366016461 0ustar  dimdimmodule {{ProjectName}}Spec (spec) where
134 | 
135 | import {{ProjectName}}
136 | 
137 | import Test.Hspec
138 | 
139 | spec :: Spec
140 | spec =
141 |     describe "main" $$ do
142 |         it "returns the unit" $$
143 |             main `shouldReturn` ()
144 | .gitattributes0000644000175000017500000000001412524653750012061 0ustar  dimdim* text=auto
145 | .gitignore0000644000175000017500000000007312524653750011163 0ustar  dimdim/.cabal-sandbox/
146 | /.hpc/
147 | /cabal.sandbox.config
148 | /dist/
149 | /tmp/
150 | .stylish-haskell.yaml0000644000175000017500000000025712524653750013261 0ustar  dimdimcolumns: 79
151 | steps:
152 | - imports:
153 |     align: none
154 | - language_pragmas:
155 |     remove_redundant: true
156 |     style: vertical
157 | - records: {}
158 | - tabs:
159 |     spaces: 4
160 | - trailing_whitespace: {}
161 | .travis.yml0000644000175000017500000000004312524653750011301 0ustar  dimdimlanguage: haskell
162 | ghc:
163 | - 7.8
164 | - 7.6
165 | CHANGELOG.md0000644000175000017500000000020612524653750011002 0ustar  dimdim# Change log
166 | 
167 | This package uses [Semantic Versioning][1].
168 | 
169 | ## v0.0.0
170 | 
171 | -   Initially created.
172 | 
173 | [1]: http://semver.org/spec/v2.0.0.html
174 | HLint.hs0000644000175000017500000000021612524653750010544 0ustar  dimdim{-# LANGUAGE PackageImports #-}
175 | 
176 | module HLint () where
177 | 
178 | import "hint" HLint.Default
179 | import "hint" HLint.Dollar
180 | import "hint" HLint.Generalise
181 | Haskeleton.hs.template0000755000175000017500000000775212540312444013442 0ustar  dimdim#!/usr/bin/env runhaskell
182 | 
183 | -- Usage: ./Haskeleton.hs New.Module
184 | module Haskeleton (main) where
185 | 
186 | import Data.List (groupBy, isInfixOf)
187 | import Data.Monoid ((<>))
188 | import System.Directory (createDirectoryIfMissing)
189 | import System.Environment (getArgs)
190 | import System.FilePath (joinPath, takeDirectory, (<.>))
191 | 
192 | main :: IO ()
193 | main = do
194 |     ms <- getArgs
195 |     mapM_ createDirectories ms
196 |     mapM_ writeFiles ms
197 |     mapM_ updateFiles ms
198 |   where
199 |     createDirectories m = do
200 |         createBenchmarkDirectory m
201 |         createLibraryDirectory m
202 |         createTestSuiteDirectory m
203 |     writeFiles m = do
204 |         writeBenchmarkFile m
205 |         writeLibraryFile m
206 |         writeTestSuiteFile m
207 |     updateFiles m = do
208 |         updateCabal m
209 |         updateCriterion m
210 |         updateLibrary m
211 | 
212 | --
213 | 
214 | createDirectory :: FilePath -> IO ()
215 | createDirectory = createDirectoryIfMissing True . takeDirectory
216 | 
217 | path :: FilePath -> String -> String -> FilePath
218 | path d s m = joinPath (d : parts (m <> s)) <.> "hs"
219 | 
220 | parts :: String -> [String]
221 | parts = split '.'
222 | 
223 | placeholder :: String
224 | placeholder = "New.Module"
225 | 
226 | pragma :: String
227 | pragma = "-- HASKELETON: "
228 | 
229 | replace :: (Eq a) => [a] -> [a] -> [a] -> [a]
230 | replace [] _ _ = []
231 | replace xs@(h : t) old new =
232 |     if a == old
233 |         then new <> replace b old new
234 |         else h : replace t old new
235 |   where
236 |     (a, b) = splitAt (length old) xs
237 | 
238 | split :: (Eq a) => a -> [a] -> [[a]]
239 | split x xs = fmap (dropWhile (== x)) (groupBy (const (x /=)) xs)
240 | 
241 | updateFile :: FilePath -> String -> IO ()
242 | updateFile p m = do
243 |     contents <- readFile p
244 |     seq (length contents) (return ())
245 |     writeFile p (unlines (go =<< lines contents))
246 |   where
247 |     go line = if pragma `isInfixOf` line
248 |         then [replace (replace line pragma "") placeholder m, line]
249 |         else [line]
250 | 
251 | -- Benchmark
252 | 
253 | createBenchmarkDirectory :: String -> IO ()
254 | createBenchmarkDirectory = createDirectory . benchmarkPath
255 | 
256 | benchmarkDirectory :: String
257 | benchmarkDirectory = "benchmark"
258 | 
259 | benchmarkPath :: String -> FilePath
260 | benchmarkPath = path benchmarkDirectory benchmarkSuffix
261 | 
262 | benchmarkTemplate :: String -> String
263 | benchmarkTemplate m = unlines
264 |     [ "module " <> m <> "Bench (benchmarks) where"
265 |     , ""
266 |     , "import " <> m <> " ()"
267 |     , ""
268 |     , "import Criterion"
269 |     , ""
270 |     , "benchmarks :: [Benchmark]"
271 |     , "benchmarks = []"
272 |     ]
273 | 
274 | benchmarkSuffix :: String
275 | benchmarkSuffix = "Bench"
276 | 
277 | writeBenchmarkFile :: String -> IO ()
278 | writeBenchmarkFile m = writeFile (benchmarkPath m) (benchmarkTemplate m)
279 | 
280 | -- Cabal
281 | 
282 | cabalPath :: FilePath
283 | cabalPath = "{{ProjectName}}.cabal"
284 | 
285 | updateCabal :: String -> IO ()
286 | updateCabal = updateFile cabalPath
287 | 
288 | -- Criterion
289 | 
290 | criterionPath :: FilePath
291 | criterionPath = benchmarkPath ""
292 | 
293 | updateCriterion :: String -> IO ()
294 | updateCriterion = updateFile criterionPath
295 | 
296 | -- Library
297 | 
298 | createLibraryDirectory :: String -> IO ()
299 | createLibraryDirectory = createDirectory . libraryPath
300 | 
301 | libraryDirectory :: String
302 | libraryDirectory = "library"
303 | 
304 | libraryPath :: String -> FilePath
305 | libraryPath = path libraryDirectory librarySuffix
306 | 
307 | libraryTemplate :: String -> String
308 | libraryTemplate m = unlines
309 |     [ "-- | TODO"
310 |     , "module " <> m <> " () where"
311 |     ]
312 | 
313 | librarySuffix :: String
314 | librarySuffix = ""
315 | 
316 | updateLibrary :: String -> IO ()
317 | updateLibrary = updateFile (libraryPath "{{ProjectName}}")
318 | 
319 | writeLibraryFile :: String -> IO ()
320 | writeLibraryFile m = writeFile (libraryPath m) (libraryTemplate m)
321 | 
322 | -- Test Suite
323 | 
324 | createTestSuiteDirectory :: String -> IO ()
325 | createTestSuiteDirectory = createDirectory . testSuitePath
326 | 
327 | testSuiteDirectory :: String
328 | testSuiteDirectory = "test-suite"
329 | 
330 | testSuitePath :: String -> FilePath
331 | testSuitePath = path testSuiteDirectory testSuiteSuffix
332 | 
333 | testSuiteTemplate :: String -> String
334 | testSuiteTemplate m = unlines
335 |     [ "module " <> m <> "Spec (spec) where"
336 |     , ""
337 |     , "import " <> m <> " ()"
338 |     , ""
339 |     , "import Test.Hspec"
340 |     , ""
341 |     , "spec :: Spec"
342 |     , "spec = it \"is\" pending"
343 |     ]
344 | 
345 | testSuiteSuffix :: String
346 | testSuiteSuffix = "Spec"
347 | 
348 | writeTestSuiteFile :: String -> IO ()
349 | writeTestSuiteFile m = writeFile (testSuitePath m) (testSuiteTemplate m)
350 | LICENSE-HASKELETON.md0000644000175000017500000000211312524653750012227 0ustar  dimdimThe MIT License (MIT)
351 | 
352 | Copyright (c) 2015 Taylor Fausak <taylor@fausak.me>
353 | 
354 | Permission is hereby granted, free of charge, to any person obtaining a copy
355 | of this software and associated documentation files (the "Software"), to deal
356 | in the Software without restriction, including without limitation the rights
357 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
358 | copies of the Software, and to permit persons to whom the Software is
359 | furnished to do so, subject to the following conditions:
360 | 
361 | The above copyright notice and this permission notice shall be included in
362 | all copies or substantial portions of the Software.
363 | 
364 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
365 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
366 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
367 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
368 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
369 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
370 | THE SOFTWARE.
371 | LICENSE.md.template0000644000175000017500000000210112540312461012370 0ustar  dimdimThe MIT License (MIT)
372 | 
373 | Copyright (c) 2015 {{author}} <{{email}}>
374 | 
375 | Permission is hereby granted, free of charge, to any person obtaining a copy
376 | of this software and associated documentation files (the "Software"), to deal
377 | in the Software without restriction, including without limitation the rights
378 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
379 | copies of the Software, and to permit persons to whom the Software is
380 | furnished to do so, subject to the following conditions:
381 | 
382 | The above copyright notice and this permission notice shall be included in
383 | all copies or substantial portions of the Software.
384 | 
385 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
386 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
387 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
388 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
389 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
390 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
391 | THE SOFTWARE.
392 | Makefile.template0000644000175000017500000000141012540312510012421 0ustar  dimdim.PHONY: all bench build clean configure haddock hpc install repl run test
393 | 
394 | all: install configure build haddock test hpc bench
395 | 
396 | bench:
397 | 	cabal bench --jobs
398 | 
399 | build:
400 | 	cabal build --jobs
401 | 
402 | clean:
403 | 	cabal clean
404 | 	if test -d .cabal-sandbox; then cabal sandbox delete; fi
405 | 	if test -d .hpc; then rm -r .hpc; fi
406 | 
407 | configure:
408 | 	cabal configure --enable-benchmarks --enable-tests
409 | 
410 | haddock:
411 | 	cabal haddock --hyperlink-source
412 | 	# dist/doc/html/{{ProjectName}}/index.html
413 | 
414 | hpc:
415 | 	hpc markup --destdir=tmp dist/hpc/tix/tests/tests.tix
416 | 	# tmp/hpc_index.html
417 | 
418 | install:
419 | 	cabal sandbox init
420 | 	cabal install --enable-benchmarks --enable-tests --jobs --only-dependencies --reorder-goals
421 | 
422 | repl:
423 | 	cabal repl lib:{{ProjectName}}
424 | 
425 | run:
426 | 	cabal run --jobs {{ProjectName}}
427 | 
428 | test:
429 | 	cabal test --jobs
430 | 	cabal check
431 | ProjectName.cabal.template0000644000175000017500000000525012540312625014171 0ustar  dimdimname: {{ProjectName}}
432 | version: 0.0.0
433 | cabal-version: >=1.10
434 | build-type: Simple
435 | license: MIT
436 | license-file: LICENSE.md
437 | copyright: 2015 {{author}} <{{email}}>
438 | maintainer: {{author}} <{{email}}>
439 | synopsis: TODO
440 | description:
441 |     TODO
442 | category: TODO
443 | author: {{author}} <{{email}}>
444 | tested-with: GHC ==7.8 GHC ==7.6
445 | extra-source-files:
446 |     CHANGELOG.md
447 |     README.md
448 | 
449 | library
450 |     exposed-modules:
451 |         {{ProjectName}}
452 |         -- HASKELETON: New.Module
453 |     build-depends:
454 |         base ==4.*
455 |     default-language: Haskell2010
456 |     hs-source-dirs: library
457 |     ghc-prof-options: -auto-all -prof
458 |     ghc-options: -Wall
459 | 
460 | executable {{ProjectName}}
461 |     main-is: Main.hs
462 |     build-depends:
463 |         base -any,
464 |         {{ProjectName}} -any
465 |     default-language: Haskell2010
466 |     hs-source-dirs: executable
467 |     ghc-prof-options: -auto-all -prof
468 |     ghc-options: -Wall
469 | 
470 | test-suite tests
471 |     type: exitcode-stdio-1.0
472 |     main-is: Spec.hs
473 |     build-depends:
474 |         base -any,
475 |         {{ProjectName}} -any,
476 |         hspec ==2.*,
477 |         HUnit -any,
478 |         QuickCheck -any
479 |     default-language: Haskell2010
480 |     hs-source-dirs: library test-suite
481 |     other-modules:
482 |         {{ProjectName}}
483 |         -- HASKELETON: New.Module
484 |         {{ProjectName}}Spec
485 |         -- HASKELETON: New.ModuleSpec
486 |     ghc-options: -fhpc -Wall -Werror
487 | test-suite examples
488 |     type: exitcode-stdio-1.0
489 |     main-is: DocTest.hs
490 |     build-depends:
491 |         base -any,
492 |         Glob ==0.7.*,
493 |         doctest ==0.9.*
494 |     default-language: Haskell2010
495 |     hs-source-dirs: test-suite
496 |     ghc-options: -Wall -Werror
497 | test-suite coverage
498 |     type: exitcode-stdio-1.0
499 |     main-is: HPC.hs
500 |     build-depends:
501 |         base -any,
502 |         directory ==1.*,
503 |         process ==1.*,
504 |         regex-compat >=0.90
505 |     default-language: Haskell2010
506 |     hs-source-dirs: test-suite
507 |     ghc-options: -Wall -Werror
508 | test-suite documentation
509 |     type: exitcode-stdio-1.0
510 |     main-is: Haddock.hs
511 |     build-depends:
512 |         base -any,
513 |         process -any,
514 |         regex-compat -any
515 |     default-language: Haskell2010
516 |     hs-source-dirs: test-suite
517 |     ghc-options: -Wall -Werror
518 | test-suite style
519 |     type: exitcode-stdio-1.0
520 |     main-is: HLint.hs
521 |     build-depends:
522 |         base -any,
523 |         hlint ==1.*
524 |     default-language: Haskell2010
525 |     hs-source-dirs: test-suite
526 |     ghc-options: -Wall -Werror
527 | 
528 | benchmark benchmarks
529 | 
530 |     if impl(ghc >=7.8)
531 |         build-depends:
532 |             criterion ==1.*
533 | 
534 |     if impl(ghc <7.8)
535 |         build-depends:
536 |             criterion ==0.6.*,
537 |             hastache <0.6,
538 |             statistics <0.11
539 |     type: exitcode-stdio-1.0
540 |     main-is: Bench.hs
541 |     build-depends:
542 |         base -any,
543 |         {{ProjectName}} -any
544 |     default-language: Haskell2010
545 |     hs-source-dirs: benchmark
546 | README-HASKELETON.md0000644000175000017500000000465612524653750012120 0ustar  dimdim# [Haskeleton][1]
547 | 
548 | [![Build Status][2]][3]
549 | 
550 | Haskeleton is a project skeleton for Haskell packages. It's a tool,
551 | like [`cabal init`][4], for creating new packages. Unlike `cabal
552 | init`, packages created by Haskeleton are fully-featured and
553 | idiomatic. Your new package will have:
554 | 
555 | - A library with its own source directory and section in the Cabal
556 |   file.
557 | 
558 | - An executable that depends on your library.
559 | 
560 | - A comprehensive test suite including unit tests, property checks,
561 |   doctests, program and documentation coverage, and code quality.
562 | 
563 | - A benchmark suite for analyzing the peformance of your library.
564 | 
565 | For a more complete explanation of these features, read [Haskeleton's
566 | introductory blog post][5]. It also describes why you might want
567 | each of these things.
568 | 
569 | Haskeleton is implemented as a template for [`hi`][6]. To create a
570 | new package, run `hi` and point it to this repository. For example:
571 | 
572 | ``` sh
573 | $ hi example \
574 |     --repository git://github.com/tfausak/haskeleton.git
575 | Creating new project with git repository:git://github.com/tfausak/haskeleton.git
576 |     create  example/.gitattributes
577 |     create  example/.gitignore
578 |     create  example/.stylish-haskell.yaml
579 |     create  example/.travis.yml
580 |     create  example/CHANGELOG.md
581 |     create  example/CONTRIBUTING.md
582 |     create  example/HLint.hs
583 |     create  example/Haskeleton.hs
584 |     create  example/LICENSE.md
585 |     create  example/Makefile
586 |     create  example/README.md
587 |     create  example/Setup.hs
588 |     create  example/benchmark/Bench.hs
589 |     create  example/benchmark/ExampleBench.hs
590 |     create  example/executable/Main.hs
591 |     create  example/library/Example.hs
592 |     create  example/example.cabal
593 |     create  example/test-suite/DocTest.hs
594 |     create  example/test-suite/HLint.hs
595 |     create  example/test-suite/HPC.hs
596 |     create  example/test-suite/Haddock.hs
597 |     create  example/test-suite/ExampleSpec.hs
598 |     create  example/test-suite/Spec.hs
599 |     create  example/tmp/.gitignore
600 | ```
601 | 
602 | Haskeleton works with `hi` version 1.x. The packages it creates
603 | work with GHC 7.8 and 7.6, along with the latest version of the
604 | Haskell platform (2014.2.0.0).
605 | 
606 | [1]: http://taylor.fausak.me/haskeleton/
607 | [2]: https://img.shields.io/travis/tfausak/haskeleton/master.svg?label=build&style=flat-square
608 | [3]: https://travis-ci.org/tfausak/haskeleton
609 | [4]: https://www.haskell.org/cabal/users-guide/developing-packages.html#using-cabal-init
610 | [5]: http://taylor.fausak.me/2014/03/04/haskeleton-a-haskell-project-skeleton/
611 | [6]: https://github.com/fujimura/hi
612 | README.md.template0000644000175000017500000000124612540312645012260 0ustar  dimdim# {{ProjectName}}
613 | 
614 | This is a new package created by [Haskeleton][]. To finish setting it up, look
615 | for "TODO"s in the Cabal file and in the library itself. To quickly get up and
616 | running, simply run `make`. See below for more detailed instructions.
617 | 
618 | [haskeleton]: http://taylor.fausak.me/haskeleton/
619 | 
620 | ``` sh
621 | # Update Cabal's list of packages.
622 | cabal update
623 | 
624 | # Initialize a sandbox and install the package's dependencies.
625 | make install
626 | 
627 | # Configure & build the package.
628 | make configure
629 | make build
630 | 
631 | # Test package.
632 | make test
633 | 
634 | # Benchmark package.
635 | make bench
636 | 
637 | # Run executable.
638 | make run
639 | 
640 | # Start REPL.
641 | make repl
642 | 
643 | # Generate documentation.
644 | make haddock
645 | 
646 | # Analyze coverage.
647 | make hpc
648 | ```
649 | Setup.hs0000644000175000017500000000014612524653750010630 0ustar  dimdimmodule Setup (main) where
650 | 
651 | import Distribution.Simple (defaultMain)
652 | 
653 | main :: IO ()
654 | main = defaultMain
655 | 


--------------------------------------------------------------------------------
/repository/templates/haskeleton.tar.metainfo:
--------------------------------------------------------------------------------
 1 | haskeleton -- [new project] generic haskell project skeleton
 2 | 
 3 | The template is imported from https://github.com/tfausak/haskeleton
 4 | 
 5 | Create a new project like this:
 6 | 
 7 | $ trurl new project MyNewProject haskeleton '{"author":"Ivan Pupkin", "email":"i.pupkin@gmail.com"}'
 8 | 
 9 | or like this:
10 | 
11 | $ trurl new project MyNewProject haskeleton 'author:Ivan_Pupkin, email:i.pupkin@gmail.com'
12 | 
13 | Pay attention, the name of the project should start from upper case!


--------------------------------------------------------------------------------
/repository/templates/servant.tar:
--------------------------------------------------------------------------------
  1 | app/0000755000175000017500000000000012621377360007751 5ustar  dimdimapp/Main.hs0000644000175000017500000000007512621377360011173 0ustar  dimdimmodule Main where
  2 | 
  3 | import Lib
  4 | 
  5 | main :: IO ()
  6 | main = mainFunc
  7 | application.conf.template0000644000175000017500000000031212624655407014155 0ustar  dimdimdatabase {
  8 |   name = "{{ProjectName}}"
  9 |   user = "{{ProjectName}}"
 10 |   password = "{{ProjectName}}"
 11 |   host = "localhost"
 12 |   port = 3306
 13 |   salt = "my-salt-123"
 14 | }
 15 | 
 16 | application {
 17 |   port = 3000
 18 |   poolSize = 10
 19 | }LICENSE0000644000175000017500000000277012621376451010204 0ustar  dimdimCopyright Author name here (c) 2015
 20 | 
 21 | All rights reserved.
 22 | 
 23 | Redistribution and use in source and binary forms, with or without
 24 | modification, are permitted provided that the following conditions are met:
 25 | 
 26 |     * Redistributions of source code must retain the above copyright
 27 |       notice, this list of conditions and the following disclaimer.
 28 | 
 29 |     * Redistributions in binary form must reproduce the above
 30 |       copyright notice, this list of conditions and the following
 31 |       disclaimer in the documentation and/or other materials provided
 32 |       with the distribution.
 33 | 
 34 |     * Neither the name of Author name here nor the names of other
 35 |       contributors may be used to endorse or promote products derived
 36 |       from this software without specific prior written permission.
 37 | 
 38 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 39 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 40 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 41 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 42 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 43 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 44 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 45 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 46 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 47 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 48 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.mysql.sql.template0000644000175000017500000000071112624663766012703 0ustar  dimdimcreate database {{ProjectName}};
 49 | grant all on {{ProjectName}}.* on {{ProjectName}}@localhost identified by '{{ProjectName}}';
 50 | 
 51 | flush privileges;
 52 | 
 53 | use {{ProjectName}};
 54 | create table `user` (id int auto_increment primary key, login varchar(128) unique not null, password varchar(128) not null);
 55 | 
 56 | -- The `user` table contains one user with login 'user' and password 'password'
 57 | insert into `user`(`login`, `password`) values('user', md5('my-salt-123password'));
 58 | ProjectName.cabal.template0000644000175000017500000000462112624655361014204 0ustar  dimdimname:                {{ProjectName}}
 59 | version:             0.1.0.0
 60 | synopsis:            Initial project template from stack
 61 | description:         Please see README.md
 62 | homepage:            http://github.com/githubuser/{{ProjectName}}#readme
 63 | license:             BSD3
 64 | license-file:        LICENSE
 65 | author:              Author name here
 66 | maintainer:          example@example.com
 67 | copyright:           2010 Author Here
 68 | category:            Web
 69 | build-type:          Simple
 70 | -- extra-source-files:
 71 | cabal-version:       >=1.10
 72 | 
 73 | library
 74 |   hs-source-dirs:      src
 75 |   exposed-modules:     Lib
 76 |                      , Auth.AuthHeader
 77 |                      , Auth.DbAuth
 78 |                      , AppConfig
 79 |                      , Db.Common                     
 80 |                      , Json.User
 81 |                      , Db.User
 82 |                      , Convert.UserConverter
 83 |                      
 84 |                      
 85 |   build-depends:       base >= 4.7 && < 5
 86 |                      , HTTP
 87 |                      , word8
 88 |                      , aeson
 89 |                      , base64-bytestring
 90 |                      , bytestring
 91 |                      , configurator
 92 |                      , http-types
 93 |                      , mysql
 94 |                      , persistent
 95 |                      , persistent-template
 96 |                      , persistent-mysql
 97 |                      , resource-pool
 98 |                      , text
 99 |                      , utf8-string
100 |                      , wai
101 |                      , wai-middleware-static
102 |                      , wai-extra
103 |                      , warp
104 |                      , monad-logger
105 |                      , MissingH
106 |                      , transformers
107 |                      , servant
108 |                      , servant-server
109 |                      , either
110 |   
111 |   default-language:    Haskell2010
112 | 
113 | executable {{ProjectName}}-exe
114 |   hs-source-dirs:      app
115 |   main-is:             Main.hs
116 |   ghc-options:         -threaded -rtsopts -with-rtsopts=-N
117 |   build-depends:       base
118 |                      , {{ProjectName}}                     
119 |   default-language:    Haskell2010
120 | 
121 | test-suite {{ProjectName}}-test
122 |   type:                exitcode-stdio-1.0
123 |   hs-source-dirs:      test
124 |   main-is:             Spec.hs
125 |   build-depends:       base
126 |                      , {{ProjectName}}
127 |   ghc-options:         -threaded -rtsopts -with-rtsopts=-N
128 |   default-language:    Haskell2010
129 | 
130 | source-repository head
131 |   type:     git
132 |   location: https://github.com/githubuser/{{ProjectName}}
133 | Setup.hs0000644000175000017500000000005612621376451010626 0ustar  dimdimimport Distribution.Simple
134 | main = defaultMain
135 | src/0000755000175000017500000000000012624655127007763 5ustar  dimdimsrc/Lib.hs0000644000175000017500000000464012624655127011031 0ustar  dimdim{-# LANGUAGE DataKinds         #-}
136 | {-# LANGUAGE OverloadedStrings #-}
137 | {-# LANGUAGE TypeFamilies      #-}
138 | {-# LANGUAGE TypeOperators     #-}
139 | 
140 | module Lib
141 |     ( mainFunc
142 |     ) where
143 | 
144 | import Network.Wai.Handler.Warp
145 | import qualified Data.Configurator as C
146 | import Data.Text
147 | import Servant
148 | 
149 | import Database.Persist.MySQL
150 | import Control.Monad.Logger
151 | 
152 | import Auth.AuthHeader
153 | import Auth.DbAuth
154 | import AppConfig
155 | import Db.Common
156 | 
157 | 
158 | import Control.Monad.IO.Class
159 | import Control.Monad.Trans.Either
160 | 
161 | 
162 | configFileName :: String
163 | configFileName = "application.conf"
164 | 
165 | 
166 | connectInfo :: AppConfig -> ConnectInfo
167 | connectInfo conf = defaultConnectInfo { connectUser = dbUser conf
168 |                                       , connectPassword = dbPassword conf
169 |                                       , connectDatabase = dbName conf
170 |                                       , connectHost = dbHost conf
171 |                                       , connectPort = dbPort conf
172 |                                       }
173 | 
174 | ---------------------------------------
175 | -- Examples section
176 | 
177 | helloUser :: ConnectionPool -> String -> Maybe Text -> EitherT ServantErr IO Text
178 | helloUser pool salt Nothing = left $ err403 { errBody = "No Authorization header found!" }
179 | helloUser pool salt (Just authHeader) =
180 |     withUser pool authHeader salt $ \user -> do
181 |         liftIO $ print user
182 |         return $ pack $ show user
183 | 
184 | hello :: EitherT ServantErr IO Text
185 | hello  = return "Hello, World!"
186 | 
187 | ---------------------------------------
188 | 
189 | type API = "helloUser" :> Header "Authorization" Text :> Get '[PlainText] Text
190 |       :<|> "hello" :> Get '[PlainText] Text
191 | 
192 | type API' = API :<|> Raw
193 | 
194 | 
195 | api :: Proxy API
196 | api = Proxy
197 | 
198 | api' :: Proxy API'
199 | api' = Proxy
200 | 
201 | server :: ConnectionPool -> String -> Server API
202 | server pool salt = helloUser pool salt
203 |               :<|> hello
204 | 
205 | server' :: ConnectionPool -> String -> Server API'
206 | server' pool salt = server pool salt
207 |                :<|> serveDirectory "static"
208 | 
209 | 
210 | ---------------------------------------
211 | 
212 | mainFunc :: IO ()
213 | mainFunc = do
214 |     putStrLn "Starting server..."
215 |     loadedConf <- C.load [C.Required configFileName]
216 |     maybeConf <- makeDbConfig loadedConf
217 |     case maybeConf of
218 |         Nothing -> putStrLn $ "Can't parse \"" ++ configFileName ++ "\" file, terminating!"
219 |         Just conf -> do
220 |             pool <- runStdoutLoggingT $ createMySQLPool (connectInfo conf) (fromIntegral $ poolSize conf)
221 |             run (fromIntegral $ appPort conf) (serve api' (server' pool (dbSalt conf)))
222 | src/Convert/0000755000175000017500000000000012624652671011404 5ustar  dimdimsrc/Convert/UserConverter.hs0000644000175000017500000000165312624651074014547 0ustar  dimdimmodule Convert.UserConverter where
223 | 
224 | import Prelude hiding (id)
225 | import GHC.Generics (Generic)
226 | import qualified Data.Aeson as A
227 | 
228 | import Database.Persist.MySQL
229 | import Data.Text
230 | 
231 | import Db.Common
232 | import qualified Db.User as D
233 | import Json.User
234 | 
235 | 
236 | toEntity (User maybeId _login _password) =
237 |     case maybeId of
238 |         Nothing -> Nothing
239 |         Just _id -> Just $ Entity (toSqlKey (fromIntegral _id) :: Key D.User) $
240 |                                 D.User _login _password
241 | 
242 | toRecord (User _ _login _password) = D.User _login _password
243 | 
244 | toJson (Entity key (D.User _login _password)) =
245 |     let vals = keyToValues key
246 |     in processKeys vals
247 |     
248 |     where processKeys [pval] =
249 |             let eitherId = fromPersistValue pval :: Either Text Int
250 |             in case eitherId of
251 |                 Left _ -> Nothing
252 |                 Right _id -> Just $ User (Just $ fromIntegral _id) _login _password
253 |                 
254 |           processKeys _ = Nothing
255 | 
256 | src/Logic/0000755000175000017500000000000012624652704011016 5ustar  dimdimsrc/Json/0000755000175000017500000000000012624652700010666 5ustar  dimdimsrc/Json/User.hs0000644000175000017500000000044312624630703012140 0ustar  dimdim{-# LANGUAGE DeriveGeneric #-}
257 | 
258 | module Json.User where
259 | 
260 | import GHC.Generics (Generic)
261 | import qualified Data.Aeson as A
262 | 
263 | data User = User {
264 |     id       :: Maybe Int
265 |   , login    :: String
266 |   , password :: String
267 |   }
268 |   deriving (Show, Generic)
269 | 
270 | instance A.ToJSON User
271 | instance A.FromJSON User
272 | src/AppConfig.hs0000644000175000017500000000261312621663611012161 0ustar  dimdim{-# LANGUAGE OverloadedStrings #-}
273 | {-# LANGUAGE DeriveGeneric #-}
274 | 
275 | module AppConfig where
276 | 
277 | import GHC.Generics (Generic)
278 | import qualified Data.Configurator as C
279 | import qualified Data.Configurator.Types as C
280 | import Data.Word
281 | 
282 | data AppConfig = AppConfig {
283 |        dbName     :: String
284 |      , dbUser     :: String
285 |      , dbPassword :: String
286 |      , dbSalt     :: String
287 |      , dbHost     :: String
288 |      , dbPort     :: Word16
289 |      , appPort    :: Word16
290 |      , poolSize   :: Word16
291 |      }
292 |      deriving (Show, Generic)
293 | 
294 | makeDbConfig :: C.Config -> IO (Maybe AppConfig)
295 | makeDbConfig conf = do
296 |   name     <- C.lookup conf "database.name"         :: IO (Maybe String)
297 |   user     <- C.lookup conf "database.user"         :: IO (Maybe String)
298 |   password <- C.lookup conf "database.password"     :: IO (Maybe String)
299 |   dsalt    <- C.lookup conf "database.salt"         :: IO (Maybe String)
300 |   host     <- C.lookup conf "database.host"         :: IO (Maybe String)
301 |   dport    <- C.lookup conf "database.port"         :: IO (Maybe Word16)
302 |   port     <- C.lookup conf "application.port"      :: IO (Maybe Word16)
303 |   psize    <- C.lookup conf "application.poolSize"  :: IO (Maybe Word16)
304 |   return $ AppConfig <$> name
305 |                      <*> user
306 |                      <*> password
307 |                      <*> dsalt
308 |                      <*> host
309 |                      <*> dport
310 |                      <*> port
311 |                      <*> psize
312 | src/Db/0000755000175000017500000000000012624652673010313 5ustar  dimdimsrc/Db/User.hs0000644000175000017500000000106712624631747011570 0ustar  dimdim{-# LANGUAGE GADTs                      #-}
313 | {-# LANGUAGE GeneralizedNewtypeDeriving #-}
314 | {-# LANGUAGE MultiParamTypeClasses      #-}
315 | {-# LANGUAGE QuasiQuotes                #-}
316 | {-# LANGUAGE TemplateHaskell            #-}
317 | {-# LANGUAGE TypeFamilies               #-}
318 | {-# LANGUAGE DeriveGeneric              #-}
319 | 
320 | module Db.User where
321 | 
322 | import GHC.Generics
323 | import Database.Persist.TH
324 | import Database.Persist
325 | import Database.Persist.Sql
326 | 
327 | share [mkPersist sqlSettings] [persistLowerCase|
328 | User
329 |     login    String
330 |     password String
331 |     deriving Show
332 |     deriving Generic
333 | |]
334 | src/Db/Common.hs0000644000175000017500000000052012624630656012071 0ustar  dimdim{-# LANGUAGE FlexibleContexts #-}
335 | module Db.Common where
336 | 
337 | import Control.Monad.IO.Class
338 | import Database.Persist.MySQL
339 | 
340 | query :: MonadIO m => ConnectionPool -> SqlPersistT IO a -> m a
341 | query pool query = liftIO $ runSqlPool query pool
342 | 
343 | toKey :: ToBackendKey SqlBackend record => Int -> Key record
344 | toKey _id = toSqlKey $ fromIntegral _id
345 | 
346 | src/Auth/0000755000175000017500000000000012624660103010652 5ustar  dimdimsrc/Auth/AuthHeader.hs0000644000175000017500000000202412624660103013216 0ustar  dimdim{-# LANGUAGE TupleSections #-}
347 | {-# LANGUAGE OverloadedStrings #-}
348 | 
349 | module Auth.AuthHeader where
350 | 
351 | import Network.Wai
352 | import Network.Wai.Handler.Warp
353 | import Data.ByteString.Base64 (decodeLenient)
354 | import qualified Data.Text as T
355 | import qualified Data.Text.Encoding as T8
356 | import qualified Data.ByteString as B
357 | import qualified Data.ByteString.Char8 as C
358 | import Data.Word8 (isSpace, _colon, toLower)
359 | import Data.Hash.MD5
360 | 
361 | extractBasicAuth :: T.Text -> Maybe (T.Text, T.Text)
362 | extractBasicAuth bs =
363 |   let (x, y) = B.break isSpace $ T8.encodeUtf8 bs
364 |   in if B.map toLower x == "basic"
365 |      then decode $ extract $ B.dropWhile isSpace y
366 |      else Nothing
367 |   where extract encoded =
368 |             let rawstr = decodeLenient encoded
369 |                 (username, password') = B.break (== _colon) rawstr
370 |             in ((username,) . snd) <$> B.uncons password'
371 |         decode Nothing = Nothing
372 |         decode (Just (u,p)) = Just (T8.decodeUtf8 u, T8.decodeUtf8 p)
373 | 
374 | encodePassword :: String -> String -> String
375 | encodePassword salt pwd = md5s $ Str $ salt ++ pwd
376 | src/Auth/DbAuth.hs0000644000175000017500000000262412624653271012371 0ustar  dimdim{-# LANGUAGE OverloadedStrings #-}
377 | module Auth.DbAuth where
378 | 
379 | import Data.Text
380 | import Database.Persist.MySQL
381 | import Database.Persist.Sql
382 | import Control.Monad.IO.Class
383 | import Control.Monad.Trans.Either
384 | import Servant.API
385 | import Servant
386 | 
387 | import Auth.AuthHeader
388 | 
389 | import Db.Common
390 | import qualified Db.User as Db
391 | import qualified Json.User as J
392 | import qualified Convert.UserConverter as C
393 | 
394 | findUser :: ConnectionPool -> Text -> Text -> String -> IO (Maybe J.User)
395 | findUser pool login password salt = do
396 |      users <- flip runSqlPool pool $
397 |                        selectList [Db.UserLogin ==. unpack login, Db.UserPassword ==. encodePassword salt (unpack password)] []
398 |      return $ oneUser users
399 |      
400 |      where oneUser [user] = C.toJson user
401 |            oneUser _ = Nothing
402 | 
403 | 
404 | authHeaderToUser :: MonadIO m => ConnectionPool -> Text -> String -> m (Maybe J.User)
405 | authHeaderToUser pool authHeader salt = do
406 |     let auth = extractBasicAuth authHeader
407 |     liftIO $ tryFindUser auth
408 | 
409 |     where tryFindUser Nothing = return Nothing
410 |           tryFindUser (Just (login, password)) = findUser pool login password salt
411 | 
412 | withUser :: ConnectionPool -> Text -> String -> (J.User -> EitherT ServantErr IO a) -> EitherT ServantErr IO a
413 | withUser pool authHeader salt func = do
414 |     maybeUser <- authHeaderToUser pool authHeader salt
415 |     case maybeUser of
416 |         Nothing -> left $ err403 { errBody = "No user found!" }
417 |         Just user -> func user
418 | stack.yaml0000644000175000017500000000175712621376452011175 0ustar  dimdim# For more information, see: https://github.com/commercialhaskell/stack/blob/release/doc/yaml_configuration.md
419 | 
420 | # Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
421 | resolver: lts-3.11
422 | 
423 | # Local packages, usually specified by relative directory name
424 | packages:
425 | - '.'
426 | 
427 | # Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
428 | extra-deps: []
429 | 
430 | # Override default flag values for local packages and extra-deps
431 | flags: {}
432 | 
433 | # Extra package databases containing global packages
434 | extra-package-dbs: []
435 | 
436 | # Control whether we use the GHC we find on the path
437 | # system-ghc: true
438 | 
439 | # Require a specific version of stack, using version ranges
440 | # require-stack-version: -any # Default
441 | # require-stack-version: >= 0.1.4.0
442 | 
443 | # Override the architecture used by stack, especially useful on Windows
444 | # arch: i386
445 | # arch: x86_64
446 | 
447 | # Extra directories used by stack for building
448 | # extra-include-dirs: [/path/to/dir]
449 | # extra-lib-dirs: [/path/to/dir]
450 | test/0000755000175000017500000000000012621376451010150 5ustar  dimdimtest/Spec.hs0000644000175000017500000000007712621376451011402 0ustar  dimdimmain :: IO ()
451 | main = putStrLn "Test suite not yet implemented"
452 | 


--------------------------------------------------------------------------------
/repository/templates/servant.tar.metainfo:
--------------------------------------------------------------------------------
1 | servant -- [new project] scaffolding for web-service with Servant
2 | 
3 | Create project like this:
4 | 
5 | $ trurl new project MyProj servant
6 | 
7 | Use mysql.sql to create a database for the generated project.


--------------------------------------------------------------------------------
/repository/templates/srv-converter:
--------------------------------------------------------------------------------
 1 | module Convert.{{entity}}Converter where
 2 | 
 3 | import Prelude hiding (id)
 4 | import GHC.Generics (Generic)
 5 | import qualified Data.Aeson as A
 6 | 
 7 | import Database.Persist.MySQL
 8 | import Data.Text
 9 | 
10 | import Db.Common
11 | import qualified Db.{{entity}} as D
12 | import Json.{{entity}}
13 | 
14 | toEntity :: {{entity}} -> Maybe (Entity D.{{entity}})
15 | toEntity domEntity =
16 |     case id domEntity of
17 |         Nothing -> Nothing
18 |         Just _id -> Just $ Entity (toSqlKey (fromIntegral _id) :: Key D.{{entity}}) $ toRecord domEntity
19 | 
20 | toRecord :: {{entity}} -> D.{{entity}}
21 | toRecord ({{entity}} _id{{#fields}} _{{key}}{{/fields}}) = D.{{entity}}{{#fields}} _{{key}}{{/fields}}
22 | 
23 | toJson :: Entity D.{{entity}} -> Maybe {{entity}}
24 | toJson (Entity key (D.{{entity}}{{#fields}} _{{key}}{{/fields}})) =
25 |     let vals = keyToValues key
26 |     in processKeys vals
27 |     
28 |     where processKeys [pval] =
29 |             let eitherId = fromPersistValue pval :: Either Text Int
30 |             in case eitherId of
31 |                 Left _ -> Nothing
32 |                 Right _id -> Just $ {{entity}} (Just $ fromIntegral _id){{#fields}} _{{key}}{{/fields}}
33 |           processKeys _ = Nothing
34 | 
35 | 


--------------------------------------------------------------------------------
/repository/templates/srv-converter.metainfo:
--------------------------------------------------------------------------------
1 | srv-converter -- [new file] converter of json entity to persistent entity and vice versa
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/repository/templates/srv-crud:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE DataKinds         #-}
 2 | {-# LANGUAGE OverloadedStrings #-}
 3 | {-# LANGUAGE TypeFamilies      #-}
 4 | {-# LANGUAGE TypeOperators     #-}
 5 | 
 6 | module Logic.{{entity}} where
 7 | 
 8 | import Database.Persist.MySQL
 9 | import Servant
10 | import Control.Monad.Trans.Either
11 | import Control.Monad.IO.Class
12 | import Data.Text hiding (replace, length, any, concat, map, filter)
13 | import Data.Char
14 | import Data.Maybe
15 | import Data.Word
16 | 
17 | import Auth.DbAuth
18 | import Db.Common
19 | import Json.{{entity}} ({{entity}}(..))
20 | import qualified Json.{{entity}} as Json{{entity}}
21 | import qualified Db.{{entity}} as Db{{entity}}
22 | import Json.User (User(..))
23 | import qualified Json.User as JsonUser
24 | import qualified Convert.{{entity}}Converter as C
25 | 
26 | 
27 | create{{entity}} :: ConnectionPool -> String -> Maybe Text -> {{entity}} -> EitherT ServantErr IO ()
28 | create{{entity}} _ _ Nothing _ = return ()
29 | create{{entity}} pool salt (Just authHeader) entity =
30 |     withUser pool authHeader salt $ \user -> do
31 |         query pool $ insert (C.toRecord entity {user_id = JsonUser.id user} :: Db{{entity}}.{{entity}})
32 |         return ()
33 | 
34 | entityBelongsToUser :: MonadIO m => ConnectionPool -> User -> Int -> m Bool
35 | entityBelongsToUser _ (User {JsonUser.id = Nothing}) _ = return False -- No user id
36 | entityBelongsToUser pool (User {JsonUser.id = _id}) _bid = do
37 |     entitys <- query pool $ selectList [Db{{entity}}.{{entity}}User_id ==. _id, Db{{entity}}.{{entity}}Id ==. toKey _bid] []
38 |     return $ length entitys == 1
39 | 
40 | update{{entity}} :: ConnectionPool -> String -> Maybe Text -> {{entity}} -> EitherT ServantErr IO ()
41 | update{{entity}} _ _ Nothing _ = return ()
42 | update{{entity}} pool salt (Just authHeader) entity =
43 |     withUser pool authHeader salt $ \user ->
44 |         case entity of
45 |             {{entity}} {Json{{entity}}.id = Nothing} -> left $ err400 { errBody = "No id specified!" }
46 |             {{entity}} {Json{{entity}}.id = Just _id} -> do
47 |                 belongs <- entityBelongsToUser pool user _id
48 |                 if belongs
49 |                     then do
50 |                         query pool $ replace (toKey _id :: Key Db{{entity}}.{{entity}})
51 |                                              (C.toRecord entity {user_id = JsonUser.id user} :: Db{{entity}}.{{entity}})
52 |                         return ()
53 |                     else return ()
54 | 
55 | delete{{entity}} :: ConnectionPool -> String -> Maybe Text -> Int -> EitherT ServantErr IO ()
56 | delete{{entity}} _ _ Nothing _ = return ()
57 | delete{{entity}} pool salt (Just authHeader) _id =
58 |     withUser pool authHeader salt $ \user -> do
59 |         belongs <- entityBelongsToUser pool user _id
60 |         if belongs
61 |             then do
62 |                 query pool $ delete (toKey _id :: Key Db{{entity}}.{{entity}})
63 |                 return ()
64 |             else return ()
65 |         
66 | 
67 | show{{entity}} :: ConnectionPool -> Int -> EitherT ServantErr IO (Maybe {{entity}})
68 | show{{entity}} pool id = do
69 |     entity <- query pool $ selectFirst [Db{{entity}}.{{entity}}Id ==. (toKey id :: Key Db{{entity}}.{{entity}})] []
70 |     return $ maybe{{entity}} entity
71 |     where maybe{{entity}} Nothing = Nothing
72 |           maybe{{entity}} (Just b) = C.toJson b
73 | 
74 | 
75 | select{{entity}}s :: ConnectionPool -> Maybe String -> Maybe String -> Maybe Word16 -> Maybe Word16 -> EitherT ServantErr IO [{{entity}}]
76 | select{{entity}}s _ Nothing _ _ _= return []
77 | select{{entity}}s _ _ Nothing _ _ = return []
78 | select{{entity}}s _ _ _ Nothing _ = return []
79 | select{{entity}}s _ _ _ _ Nothing = return []
80 | select{{entity}}s pool (Just field) (Just searchStr) (Just offset) (Just limit) = do
81 |     let entityField = case field of
82 |                         "title" -> Db{{entity}}.{{entity}}Title
83 |                         "author" -> Db{{entity}}.{{entity}}Author
84 |                         "content" -> Db{{entity}}.{{entity}}Content
85 |     if any (not . isAlphaNum) searchStr
86 |         then return []
87 |         else do
88 |             entitys <- query pool $ selectList [Filter entityField (Left $ concat ["%", searchStr, "%"]) (BackendSpecificFilter "like")]
89 |                                             [OffsetBy $ fromIntegral offset, LimitTo $ fromIntegral limit]
90 |             return $ map (\(Just b) -> b) $ filter isJust $ map C.toJson entitys
91 | 


--------------------------------------------------------------------------------
/repository/templates/srv-crud.metainfo:
--------------------------------------------------------------------------------
1 | srv-crud -- [new file] crud operations for user dependent db entity
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/repository/templates/srv-db-entity:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE GADTs                      #-}
 2 | {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 3 | {-# LANGUAGE MultiParamTypeClasses      #-}
 4 | {-# LANGUAGE QuasiQuotes                #-}
 5 | {-# LANGUAGE TemplateHaskell            #-}
 6 | {-# LANGUAGE TypeFamilies               #-}
 7 | {-# LANGUAGE DeriveGeneric              #-}
 8 | 
 9 | module Db.{{entity}} where
10 | 
11 | import GHC.Generics
12 | import Database.Persist.TH
13 | import Database.Persist
14 | import Database.Persist.Sql
15 | 
16 | share [mkPersist sqlSettings] [persistLowerCase|
17 | {{entity}}
18 | {{#fields}}
19 |     {{key}} {{value}}
20 | {{/fields}}    
21 |     deriving Eq
22 |     deriving Show
23 |     deriving Generic
24 | |]
25 | 
26 | 


--------------------------------------------------------------------------------
/repository/templates/srv-db-entity.metainfo:
--------------------------------------------------------------------------------
1 | srv-db-entity -- [new file] generate persistent entity
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/repository/templates/srv-json-entity:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | {-# LANGUAGE DeriveGeneric #-}
 3 | 
 4 | module Json.{{entity}} where
 5 | 
 6 | import GHC.Generics (Generic)
 7 | import qualified Data.Aeson as A
 8 | 
 9 | data {{entity}} = {{entity}} {
10 |     id       :: Maybe Int
11 | {{#fields}}
12 |   , {{key}} :: {{value}}
13 | {{/fields}}
14 |   }
15 |   deriving (Show, Generic)
16 | 
17 | instance A.ToJSON {{entity}}
18 | instance A.FromJSON {{entity}}
19 | 


--------------------------------------------------------------------------------
/repository/templates/srv-json-entity.metainfo:
--------------------------------------------------------------------------------
1 | srv-json-entity -- [new file] generate json entity
2 | 
3 | Use it with servant project template.


--------------------------------------------------------------------------------
/src/Main.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | 
 3 | module Main where
 4 | 
 5 | import Trurl
 6 | import SimpleParams
 7 | 
 8 | import System.Environment
 9 | 
10 | help :: IO ()
11 | help = do
12 |   putStrLn "trurl <command> [parameters]"
13 |   putStrLn "  update -- fetch the updates from repository"
14 |   putStrLn "  new project <name> <project_template> [parameters] -- create project of specified type with specified name; optionally add parameters"
15 |   putStrLn "  new project <name> <project_template> -j [parameters_string] -- create project of specified type with specified name; optionally add JSON parameters, wrap it with \"\" or ''"
16 |   putStrLn "  new file <name> <file_template> [parameters] -- create file from the template with specified string parameters"
17 |   putStrLn "  new file <name> <file_template> -j [parameters_string] -- create file from the template with specified JSON parameters, wrap it with \"\" or ''"
18 |   putStrLn "  list -- print all available templates"
19 |   putStrLn "  help <template> -- print template info"
20 |   putStrLn "  help -- print this help"
21 |   putStrLn "  version -- print version"
22 | 
23 | printVersion :: IO ()
24 | printVersion = putStrLn "0.4.1.x"
25 | 
26 | main :: IO ()
27 | main = do
28 |   args <- getArgs
29 |   case args of
30 |     []                                      -> help
31 |     ["--help"]                              -> help
32 |     ["-h"]                                  -> help
33 |     ["help"]                                -> help
34 |     ["help", template]                      -> helpTemplate template
35 |     ["update"]                              -> updateFromRepository
36 |     ["new", "project", name, project]       -> createProject name project "{}"
37 |     ["new", "project", name, project, "-j", params] -> createProject name project params
38 |     ["new", "project", name, project, params]       -> createProject name project $ simpleParamsToJson params
39 |     ["new", "file", name, template, "-j" ,params]   -> newTemplate name template params
40 |     ["new", "file", name, template, params] -> newTemplate name template $ simpleParamsToJson params
41 |     ["list"]                                -> listTemplates
42 |     ["version"]                             -> printVersion
43 |     ["--version"]                           -> printVersion
44 |     ["-v"]                                  -> printVersion
45 |     _                                       -> putStrLn "Unknown command"
46 | 


--------------------------------------------------------------------------------
/src/Registry.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | {-# LANGUAGE DeriveGeneric #-}
 3 | 
 4 | module Registry where
 5 | 
 6 | import Data.Aeson
 7 | import GHC.Generics (Generic)
 8 | 
 9 | data Registry = Registry { url :: String
10 |                          , templateName :: String
11 |                          }
12 |   deriving (Show, Generic)                
13 | 
14 | instance ToJSON Registry
15 | instance FromJSON Registry
16 | 


--------------------------------------------------------------------------------
/src/SimpleParams.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | 
 3 | module SimpleParams where
 4 | 
 5 | import Data.List.Split
 6 | import Data.String.Utils (endswith, replace)
 7 | import Safe
 8 | import Data.Char
 9 | 
10 | parseEmbedded :: String -> String
11 | parseEmbedded str =
12 |   case splitOn "#" str of
13 |     [k, v] ->
14 |       if endswith "@" v
15 |         then "{\"key\":\"" ++ k ++ "\",\"value\":\"" ++ replace "@" "" v ++ "\",\"last\":true}"
16 |         else "{\"key\":\"" ++ k ++ "\",\"value\":\"" ++ v ++ "\"}"
17 |     _ -> ""
18 | 
19 | processPart :: String -> String
20 | processPart str
21 |     | isDigit symb                  = str
22 |     | symb `elem` specialCharacters = str
23 |     | '#'  `elem` str               = parseEmbedded str
24 |     | otherwise                     = "\"" ++ str ++ "\""
25 |   where
26 |     symb = headDef ' ' str
27 | 
28 | simpleParamsToJson :: String -> String
29 | simpleParamsToJson sparams = "{" ++  concatMap processPart (splitOnSpecialCharacters sparams) ++ "}"
30 | 
31 | splitOnSpecialCharacters :: String -> [String]
32 | splitOnSpecialCharacters = split $ dropBlanks $ oneOf specialCharacters
33 | 
34 | specialCharacters :: String
35 | specialCharacters = ",:[]{} "
36 | 


--------------------------------------------------------------------------------
/src/Trurl.hs:
--------------------------------------------------------------------------------
  1 | {-# LANGUAGE OverloadedStrings #-}
  2 | 
  3 | module Trurl where
  4 | 
  5 | import System.Directory
  6 | import System.FilePath
  7 | import Network.HTTP.Conduit
  8 | import Codec.Archive.Tar
  9 | import Data.List hiding (find)
 10 | import Text.Hastache
 11 | import Text.Hastache.Aeson
 12 | import Data.Aeson
 13 | import Data.String.Utils
 14 | import System.FilePath.Find (find, always, fileName, extension, (==?), liftOp)
 15 | import Safe
 16 | 
 17 | import qualified Data.Text as T
 18 | import qualified Data.Text.Lazy.IO as TL
 19 | import qualified Data.ByteString.Lazy as BL
 20 | import qualified Data.ByteString.Lazy.Char8 as BLC8
 21 | 
 22 | import Registry
 23 | 
 24 | constProjectName :: String
 25 | constProjectName = "ProjectName"
 26 | 
 27 | registryUrl :: String
 28 | registryUrl = "https://github.com/dbushenko/trurl/raw/master/repository/registry.json"
 29 | 
 30 | templateExt :: String
 31 | templateExt = ".template"
 32 | 
 33 | getLocalRepoDir :: IO FilePath
 34 | getLocalRepoDir = do
 35 |   home <- getHomeDirectory
 36 |   return $ home ++ "/.trurl/repo/"
 37 | 
 38 | printFile :: FilePath -> FilePath -> IO ()
 39 | printFile dir fp = do
 40 |   file <- readFile (dir ++ fp)
 41 |   putStrLn file
 42 | 
 43 | printFileHeader :: FilePath -> FilePath -> IO ()
 44 | printFileHeader dir fp = do
 45 |   file <- readFile (dir ++ fp)
 46 |   putStrLn $ headDef "No info found..." $ lines file
 47 | 
 48 | processTemplate :: String -> String -> FilePath -> IO ()
 49 | processTemplate projName paramsStr filePath  = do
 50 |   generated <- hastacheFile defaultConfig filePath (mkProjContext projName paramsStr)
 51 |   TL.writeFile (dropExtension filePath) generated
 52 |   removeFile filePath
 53 |   return ()
 54 | 
 55 | getFullFileName :: FilePath -> String -> FilePath
 56 | getFullFileName repoDir template = repoDir ++ template
 57 | 
 58 | mkJsonContext :: Monad m => String -> MuContext m
 59 | mkJsonContext =
 60 |   maybe mkEmptyContext jsonValueContext . decode . BLC8.pack
 61 | 
 62 | mkEmptyContext :: Monad m => MuContext m
 63 | mkEmptyContext = const $ return MuNothing
 64 | 
 65 | mkProjContext :: Monad m => String -> String -> MuContext m
 66 | mkProjContext projName paramsStr =
 67 |   assoc "ProjectName" projName $ mkJsonContext paramsStr
 68 | 
 69 | mkFileContext :: Monad m => FilePath -> String -> MuContext m
 70 | mkFileContext fname paramsStr =
 71 |   assoc "FileName" fname $ mkJsonContext paramsStr
 72 | 
 73 | assoc :: (Monad m, MuVar a) => T.Text -> a -> MuContext m -> MuContext m
 74 | assoc newKey newVal oldCtx k =
 75 |   if k == newKey
 76 |     then return $ MuVariable newVal
 77 |     else oldCtx k
 78 | 
 79 | substituteProjectName :: String -> FilePath -> FilePath
 80 | substituteProjectName projectName filePath  =
 81 |   let (dirName, oldFileName) = splitFileName filePath
 82 |       newFileName = replace constProjectName projectName oldFileName
 83 |    in dirName </> newFileName
 84 | 
 85 | downloadTemplate :: String -> Registry -> IO ()
 86 | downloadTemplate repoDir (Registry u tname) = do
 87 |     let tFile = repoDir ++ tname
 88 |         mname = tname ++ ".metainfo"
 89 |         mFile = repoDir ++ mname
 90 |         fullUrl = if endswith "/" u then u else u ++ "/"
 91 | 
 92 |     putStrLn $ "Fetching " ++ fullUrl ++ tname
 93 |     simpleHttp (fullUrl ++ tname) >>= BL.writeFile tFile
 94 | 
 95 |     putStrLn $ "Fetching " ++ fullUrl ++ mname
 96 |     simpleHttp (fullUrl ++ mname) >>= BL.writeFile mFile
 97 | 
 98 | -------------------------------------
 99 | -- API
100 | --
101 | 
102 | -- Команда "update"
103 | -- 1) Создать $HOME/.trurl/repo
104 | -- 2) Забрать из репозитория реестр шаблонов
105 | -- 3) Распарсить реестр как json
106 | -- 4) Для каждого элемента реестра скачать шаблон и metainfo
107 | --
108 | updateFromRepository :: IO ()
109 | updateFromRepository = do
110 |   repoDir <- getLocalRepoDir
111 |   createDirectoryIfMissing True repoDir
112 |   putStrLn "Fetching registry..."
113 |   regFile <- simpleHttp registryUrl
114 |   case eitherDecode regFile :: Either String [Registry] of
115 |       Left msg -> putStrLn $ "Can't parse registry file!\n" ++ msg
116 |       Right registry -> mapM_ (downloadTemplate repoDir) registry
117 |   
118 | -- Команда "create <name> <project> [parameters]"
119 | -- 1) Найти в $HOME/.trurl/repo архив с именем project.tar
120 | -- 2) Создать директорию ./name
121 | -- 3) Распаковать в ./name содержимое project.tar
122 | -- 4) Найти все файлы с расширением ".template"
123 | -- 5) Отрендерить эти темплейты c учетом переданных parameters
124 | -- 6) Сохранить отрендеренные файлы в новые файлы без ".template"
125 | -- 7) Удалить все файлы с расширением ".template"
126 | -- 8) Найти все файлы с именем ProjectName независимо от расширения
127 | -- 9) Переименовать эти файлы в соотествии с указанным ProjectName
128 | --
129 | createProject :: String -> String -> String -> IO ()
130 | createProject name project paramsStr = do
131 |   -- Extract the archive
132 |   repoDir <- getLocalRepoDir
133 |   createDirectoryIfMissing True name
134 |   extract name $ repoDir ++ project ++ ".tar"
135 | 
136 |   -- Process all templates
137 |   templatePaths <- find always (extension ==? templateExt) name
138 |   mapM_ (processTemplate name paramsStr) templatePaths
139 | 
140 |   -- Find 'ProjectName' files
141 |   let checkFileName fname templname = isInfixOf templname fname
142 |   projNamePaths <- find always (liftOp checkFileName fileName constProjectName) name
143 | 
144 |   -- Rename 'ProjectName' files
145 |   let renameProjNameFile fpath = renameFile fpath (substituteProjectName name fpath)
146 |   mapM_ renameProjNameFile projNamePaths
147 | 
148 | 
149 | -- Команда "new <file> [parameters]"
150 | -- 1) Найти в $HOME/.trurl/repo архив с именем file.hs.
151 | --    Если имя файла передано с расширением, то найти точное имя файла, не подставляя *.hs
152 | -- 2) Прочитать содержимое шаблона
153 | -- 3) Отрендерить его с применением hastache и переданных параметров
154 | -- 4) Записать файл в ./
155 | --
156 | newTemplate :: String -> String -> String -> IO ()
157 | newTemplate name tName paramsStr = do
158 |   repoDir <- getLocalRepoDir
159 |   let templPath = getFullFileName repoDir tName
160 |   generated <- hastacheFile defaultConfig templPath (mkFileContext name paramsStr)
161 |   TL.writeFile name generated
162 | 
163 | -- Команда "list"
164 | -- 1) Найти все файлы с расширением '.metainfo'
165 | -- 2) Для каждого найденного файла вывести первую строчку
166 | --
167 | listTemplates :: IO ()
168 | listTemplates = do
169 |   repoDir <- getLocalRepoDir
170 |   files <- getDirectoryContents repoDir
171 |   let mpaths = filter (endswith ".metainfo") $ sort files
172 |   mapM_ (printFileHeader repoDir) mpaths
173 | 
174 | -- Команда "help <template>"
175 | -- 1) Найти указанный файл с расширением '.metainfo'
176 | -- 2) Вывести его содержимое
177 | --
178 | helpTemplate :: String -> IO ()
179 | helpTemplate template = do
180 |   repoDir <- getLocalRepoDir
181 |   templExists <- doesFileExist $ repoDir ++ template ++ ".metainfo"
182 |   if templExists then printFile repoDir $ template ++ ".metainfo"
183 |   else printFile repoDir (template ++ ".tar.metainfo")
184 | 


--------------------------------------------------------------------------------
/stack.yaml:
--------------------------------------------------------------------------------
1 | flags: {}
2 | packages:
3 | - '.'
4 | extra-deps:
5 | - hastache-aeson-0.1.1.0
6 | resolver: lts-3.9
7 | 


--------------------------------------------------------------------------------
/tests/Main.hs:
--------------------------------------------------------------------------------
 1 | {-# LANGUAGE OverloadedStrings #-}
 2 | 
 3 | module Main where
 4 | 
 5 | import Test.Tasty
 6 | import Test.Tasty.HUnit
 7 | import Text.Hastache
 8 | 
 9 | import qualified Trurl as T
10 | import qualified SimpleParams as S
11 | 
12 | main :: IO ()
13 | main = defaultMain tests
14 | 
15 | tests :: TestTree
16 | tests = testGroup "Tests" [trurlTests, simplParamsTests]
17 | 
18 | trurlTests :: TestTree
19 | trurlTests = testGroup "Trurl unit tests"
20 |   [ testCase "mkJsonContext empty" $ do
21 |       generated <- hastacheStr defaultConfig "" (T.mkJsonContext "{\"a\":11}")
22 |       assertEqual "Checking generated text" "" generated
23 | 
24 |   , testCase "mkJsonContext absent variable" $ do
25 |       generated <- hastacheStr defaultConfig "{{b}}" (T.mkJsonContext "{\"a\":11}")
26 |       assertEqual "Checking generated text" "" generated
27 | 
28 |   , testCase "mkJsonContext simple object" $ do
29 |       generated <- hastacheStr defaultConfig "{{a}}" (T.mkJsonContext "{\"a\":11}")
30 |       assertEqual "Checking generated text" "11" generated
31 | 
32 |   , testCase "mkJsonContext complex object" $ do
33 |       generated <- hastacheStr defaultConfig "{{a}}-{{b}}" (T.mkJsonContext "{\"a\":11,\"b\":\"abc\"}")
34 |       assertEqual "Checking generated text" "11-abc" generated
35 | 
36 |   , testCase "mkJsonContext complex array" $ do
37 |       generated <- hastacheStr defaultConfig "{{#abc}}{{name}}{{/abc}}" (T.mkJsonContext "{\"abc\":[{\"name\":\"1\"},{\"name\":\"2\"},{\"name\":\"3\"}]}")
38 |       assertEqual "Checking generated text" "123" generated
39 | 
40 |   , testCase "mkJsonContext nested object" $ do
41 |       generated <- hastacheStr defaultConfig "{{#abc}}{{name}}{{/abc}}" (T.mkJsonContext "{\"abc\":{\"name\":\"1\"}}")
42 |       assertEqual "Checking generated text" "1" generated
43 | 
44 |   , testCase "mkProjContext for empty params" $ do
45 |       generated <- hastacheStr defaultConfig "{{ProjectName}}" (T.mkProjContext "abc" "{}")
46 |       assertEqual "Checking generated text" "abc" generated
47 |   ]
48 | 
49 | 
50 | simplParamsTests :: TestTree
51 | simplParamsTests = testGroup "Trurl unit tests"
52 |   [ testCase "parseEmbedded without delimiter" $
53 |       assertEqual "Checking parseEmbedded" "" (S.parseEmbedded "abc")
54 | 
55 |   , testCase "parseEmbedded with delimiter" $
56 |       assertEqual "Checking parseEmbedded" "{\"key\":\"abc\",\"value\":\"efg\"}" (S.parseEmbedded "abc#efg")
57 | 
58 |   , testCase "parseEmbedded with delimiter" $
59 |       assertEqual "Checking parseEmbedded" "{\"key\":\"abc\",\"value\":\"efg\",\"last\":true}" (S.parseEmbedded "abc#efg@")
60 | 
61 |   , testCase "simpleParamsToJson" $
62 |       assertEqual "Checking simpleParamsToJson"
63 |                   "{\"abc\":123,\"efg\":456,\"zxc\":[1,2,3],\"ttt\":[{\"key\":\"abc\",\"value\":\"efg\"},{\"key\":\"hck\",\"value\":\"qwe\"},{\"key\":\"zxc\",\"value\":\"vbn\",\"last\":true}]}"
64 |                   (S.simpleParamsToJson "abc:123,efg:456,zxc:[1,2,3],ttt:[abc#efg,hck#qwe,zxc#vbn@]")
65 | 
66 |   , testCase "simple params with a space" $
67 |       assertEqual "Checking simple params with a space"
68 |                   "{\"props\":[{\"key\":\"cover\",\"value\":\"Text\"}, {\"key\":\"year\",\"value\":\"Integer\",\"last\":true}]}"
69 |                   (S.simpleParamsToJson "props:[cover#Text, year#Integer@]")
70 | 
71 |   ]
72 | 


--------------------------------------------------------------------------------
/trurl.cabal:
--------------------------------------------------------------------------------
 1 | name:                trurl
 2 | version:             0.4.1.0
 3 | synopsis:            Haskell template code generator
 4 | description:
 5 |     Trurl is a haskell project and code generating utility. Use it for scaffolding your projects and entities.
 6 |     Quick start:
 7 |     .
 8 |             trurl new project MyProject haskeleton
 9 |     .        
10 |     Trurl allows creating your own templates for projects as well as for files.
11 |     
12 | homepage:            http://github.com/dbushenko/trurl
13 | license:             BSD3
14 | license-file:        LICENSE
15 | author:              dbushenko
16 | maintainer:          d.bushenko@gmail.com
17 | -- copyright:           
18 | category:            Development
19 | build-type:          Simple
20 | -- extra-source-files:  
21 | cabal-version:       >=1.10
22 | 
23 | library
24 |     
25 |   exposed-modules:     Trurl
26 |                      , SimpleParams
27 |                      , Registry
28 |                      
29 |   hs-source-dirs:      src
30 |   build-depends:       base >= 4.7 && < 5
31 |                      , http-conduit
32 |                      , directory
33 |                      , bytestring
34 |                      , text
35 |                      , tar
36 |                      , hastache
37 |                      , aeson
38 |                      , hastache-aeson
39 |                      , unordered-containers
40 |                      , MissingH
41 |                      , filemanip
42 |                      , safe
43 |                      , filepath
44 |                      , split
45 | 
46 |   default-language:    Haskell2010
47 | 
48 | 
49 | executable trurl
50 |   main-is:             src/Main.hs
51 |   build-depends:       base >= 4.7 && < 5
52 |                      , trurl
53 | 
54 |   default-language:    Haskell2010
55 | 
56 | 
57 |   
58 | test-suite tests
59 |   default-language: Haskell2010
60 |   type:             exitcode-stdio-1.0
61 |   main-is:          tests/Main.hs
62 |   build-depends:    base >= 4.7 && < 5
63 |                   , hastache
64 |                   , tasty
65 |                   , tasty-hunit
66 |                   , trurl
67 |                   


--------------------------------------------------------------------------------