ABC
2 |
3 |
4 |
5 | DEF
6 | GHI
8 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Links/BackticksInLinks.html: -------------------------------------------------------------------------------- 1 |the right bracket character (])
То лпой is a Russian word with a tab inside.
2 | this is a block
3 |
4 |
5 | Here is some inline html.
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Links/Entities.markdown:
--------------------------------------------------------------------------------
1 |
2 | this is a block
3 |
4 | Here is some inline html.
5 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/ListsAndHRs.html: -------------------------------------------------------------------------------- 1 |-
2 |
- item 1
3 |
-
4 |
- item 2 5 |
6 |
8 | -------------------------------------------------------------------------------- /parser/tests/test-files/good/Otherwise.elm: -------------------------------------------------------------------------------- 1 | module Otherwise where 2 | 3 | otherwise = 3 4 | 5 | boo = if False then "Yay" else "Boo" 6 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.17/AllSyntax/Module.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.Module exposing ((===), D, a, b, c) 2 | 3 | 4 | a = 5 | 1 6 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.17/AllSyntax/Range.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.Expressions exposing (range) 2 | 3 | 4 | range = 5 | [1..2] 6 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.17/Export.elm: -------------------------------------------------------------------------------- 1 | module Export exposing (export) 2 | 3 | 4 | export : String 5 | export = 6 | "export" 7 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/Export.elm: -------------------------------------------------------------------------------- 1 | module Export exposing (export) 2 | 3 | 4 | export : String 5 | export = 6 | "export" 7 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/TrickyModule4.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (effect) 2 | 3 | 4 | effect mod = 5 | () 6 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Blockquotes/Indents.markdown: -------------------------------------------------------------------------------- 1 | > one 2 | > blockquote 3 | 4 | >>> triply nested 5 | > > > triply nested 6 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/ListsAndSetextHeaders.html: -------------------------------------------------------------------------------- 1 |
-
2 |
- item 3 |
- item 4 | Not header 5 |
7 | -------------------------------------------------------------------------------- /package/linux/archlinux/.gitignore: -------------------------------------------------------------------------------- 1 | .vagrant 2 | elm-format-0.16-bin 3 | elm-format-0.17-bin 4 | elm-format-0.18-bin 5 | elm-format-0.19-bin 6 | -------------------------------------------------------------------------------- /parser/tests/test-files/good/Soundness/ApplyAnnotated.elm: -------------------------------------------------------------------------------- 1 | 2 | apply : (a -> b) -> a -> b 3 | apply f = let g x = f x 4 | in g 5 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/TrickyModule3.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (portModule) 2 | 3 | 4 | portModule = 5 | () 6 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/TightLooseMore.html: -------------------------------------------------------------------------------- 1 |
-
2 |
foo
3 |-
4 |
- bar 5 |
blah
7 |
~~~
2 | ```
3 |
5 | ~~~~
6 |
7 | 2 |8 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/ConsecutiveLists.markdown: -------------------------------------------------------------------------------- 1 | * one 2 | * one 3 | + two 4 | + two 5 | - three 6 | - three 7 | 1. four 8 | 1. four 9 | 1) five 10 | 1) five 11 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/ApiSketch.elm: -------------------------------------------------------------------------------- 1 | module ApiSketch exposing (..) 2 | 3 | 4 | encode : Stats -> Json.Encode.Value 5 | 6 | 7 | decoder : Json.Decode.Decoder Stats 8 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.19/ReplaceThenByOfInCase.elm: -------------------------------------------------------------------------------- 1 | type Foo = A | B | C 2 | 3 | a = A 4 | 5 | b = case a then 6 | A -> 1 7 | B -> 2 8 | C -> 3 9 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.19/TransformFatArrow.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (foo) 2 | 3 | 4 | foo : Int -> Int -> Int -> Int 5 | foo = 6 | \a b c -> a + b + c 7 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/DocCommentsStartingWtihAtDocs.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (x) 2 | 3 | {-| 4 | 5 | @docs x 6 | 7 | -} 8 | 9 | 10 | x = 11 | () 12 | -------------------------------------------------------------------------------- /package/win/shell/main.cmd: -------------------------------------------------------------------------------- 1 | @powershell -NoProfile -ExecutionPolicy Bypass -File "%systemdrive%\vagrant\shell\InstallChocolatey.ps1" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin" 2 | -------------------------------------------------------------------------------- /cabal.project: -------------------------------------------------------------------------------- 1 | packages: 2 | ./avh4-lib, 3 | ./elm-format-markdown, 4 | ./elm-format-lib, 5 | ./elm-format-test-lib, 6 | ./ 7 | ./Shakefile 8 | with-compiler: ghc-9.6.7 9 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Code/BlankLinesAtEnd.markdown: -------------------------------------------------------------------------------- 1 | * List 2 | 3 | code 4 | 5 | 6 | * one 7 | * two 8 | 9 | 10 | 11 | * one 12 | not code 13 | 14 | * two 15 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Links/Entities.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/InBlockquote.markdown: -------------------------------------------------------------------------------- 1 | > - tight 2 | > - tight 3 | 4 | 5 | > - loose 6 | > 7 | > - loose 8 | 9 | 10 | > - one-item list 11 | 12 | > - one-item list 13 | -------------------------------------------------------------------------------- /tests/test-files/from-json/Elm-0.19/ModuleComments.elm: -------------------------------------------------------------------------------- 1 | module ModuleComments exposing (f) 2 | 3 | 4 | 5 | -- Default comment 6 | {- Block comment -} 7 | 8 | 9 | f = 10 | () 11 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/LenientEqualsColon.elm: -------------------------------------------------------------------------------- 1 | 2 | 3 | type alias Foo = 4 | { x = Int 5 | , y = () 6 | } 7 | 8 | 9 | foo = 10 | { x : Int, y : Int } 11 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/EmptyListItem.html: -------------------------------------------------------------------------------- 1 |foo
3 |4 |6 |bar
5 |foo
7 |
-
2 |
- one 3 | 4 |
- three 5 |
-
7 |
- one 8 | 9 |
- three 10 |
2 |9 | -------------------------------------------------------------------------------- /elm-format-test-lib/src/Expect.hs: -------------------------------------------------------------------------------- 1 | module Expect where 2 | 3 | import Test.Tasty.HUnit ((@=?)) 4 | 5 | 6 | equals :: (Eq a, Show a) => a -> a -> IO () 7 | equals expected actual = 8 | expected @=? actual 9 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/QuickCheck-94f37da84c1310f03dcfa1059ce870b73c94a825--6449652945938213463.elm: -------------------------------------------------------------------------------- 1 | module{-A-}Main{-A-}(..) 2 | where 3 | 4 | foo{-A-}{-B-}=--A 5 | (a,--A 6 | b,c{-A-})--A 7 | -------------------------------------------------------------------------------- /elm-format-lib/src/ElmFormat/AST/PublicAST/Config.hs: -------------------------------------------------------------------------------- 1 | module ElmFormat.AST.PublicAST.Config (Config(..)) where 2 | 3 | 4 | newtype Config = 5 | Config 6 | { showSourceLocation :: Bool 7 | } 8 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.19/DistinguishCharStartFromRef.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (a, b) 2 | 3 | 4 | a = 5 | String.fromChar '!' 6 | 7 | 8 | b = 9 | identity (String.fromChar '!') 10 | -------------------------------------------------------------------------------- /.dockerignore: -------------------------------------------------------------------------------- 1 | * 2 | !cabal.config 3 | !cabal.project 4 | !cabal.project.freeze 5 | !elm-format.cabal 6 | !elm-format-markdown 7 | !elm-format-lib 8 | !src 9 | !generated 10 | !elm-format-test-lib 11 | !avh4-lib 12 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/Start.markdown: -------------------------------------------------------------------------------- 1 | 4. this list starts with 4. 2 | 5. and continues 3 | 1. the continuation number is irrelevant. 4 | 5 | 2001) a space odyssey 6 | 7 | 1. standard lists get no start attribute 8 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/HTML/Inline.markdown: -------------------------------------------------------------------------------- 1 | hi 2 | `hi` 3 |A list within a blockquote:
3 |4 |
8 |- asterisk 1
5 |- asterisk 2
6 |- asterisk 3
7 |
16 |
20 |
--------------------------------------------------------------------------------
/elm-format-lib/src/AST/Helpers.hs:
--------------------------------------------------------------------------------
1 | module AST.Helpers where
2 |
3 | import qualified Data.Char as Char
4 |
5 |
6 | isOp :: String -> Bool
7 | isOp name =
8 | all isSymbol name
9 |
10 |
11 | isSymbol :: Char -> Bool
12 | isSymbol c =
13 | Char.isSymbol c || elem c ("+-/*=.$<>:&|^?%#@~!" :: String)
14 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Original/Code_Blocks.markdown:
--------------------------------------------------------------------------------
1 | code block on the first line
2 |
3 | Regular text.
4 |
5 | code block indented by spaces
6 |
7 | Regular text.
8 |
9 | the lines in this block
10 | all contain trailing spaces
11 |
12 | Regular Text.
13 |
14 | code block on the last line
--------------------------------------------------------------------------------
/tests/test-files/good/Elm-0.18/AllSyntax/Expressions/Unary.elm:
--------------------------------------------------------------------------------
1 | module Main exposing (multilineUnaryOperator, unaryOperator)
2 |
3 |
4 | unaryOperator a =
5 | -(a - 1) + -2 + -a
6 |
7 |
8 | multilineUnaryOperator a =
9 | -(if a then
10 | 1
11 |
12 | else
13 | 2
14 | )
15 |
--------------------------------------------------------------------------------
/tests/test-files/transform/Elm-0.19/ExplicitlyListExposedValues.formatted.elm:
--------------------------------------------------------------------------------
1 | module Main exposing (Foo(..), X, check, x)
2 |
3 |
4 | x =
5 | ()
6 |
7 |
8 | type alias X =
9 | String
10 |
11 |
12 | type Foo
13 | = A
14 | | B
15 | | C
16 |
17 |
18 | port check : String -> Cmd msg
19 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Code/IndentedFences.markdown:
--------------------------------------------------------------------------------
1 | ```
2 | a
3 | ```
4 |
5 | ```
6 | z
7 | ```
8 |
9 | ```
10 | a
11 | a
12 | a
13 | a
14 | ```
15 |
16 | * foo
17 |
18 | ```
19 | Hello
20 |
21 | ```
22 |
23 | World
24 | ```
25 |
26 | > ```
27 | >a
28 | >```
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Original/Blockquotes_with_code_blocks.html:
--------------------------------------------------------------------------------
1 |
17 | # not a header
18 |
19 | 2 |13 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Code/BlankLines.markdown: -------------------------------------------------------------------------------- 1 | foo 2 | 3 | 4 | 5 | bar 6 | > foo 7 | > 8 | > 9 | > 10 | > bar 11 | foo 12 | 13 | 14 | 15 | bar 16 | 17 | 1. One 18 | 19 | CodeA 20 | 21 | CodeB 22 | 23 | 2. Two 24 | 25 | CodeA 26 | 27 | 28 | 1. One 29 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/Start.html: -------------------------------------------------------------------------------- 1 |Example:
3 |7 |sub status { 4 | print "working"; 5 | } 6 |Or:
8 |12 |sub status { 9 | return "working"; 10 | } 11 |
-
2 |
- this list starts with 4. 3 |
- and continues 4 |
- the continuation number is irrelevant. 5 |
-
7 |
- a space odyssey 8 |
-
10 |
- standard lists get no start attribute 11 |
This is the simple case.
2 |This one has a line 3 | break.
4 |This one has a line 5 | break with a line-ending space.
6 | 7 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/AllSyntax/Patterns.elm: -------------------------------------------------------------------------------- 1 | module Patterns exposing (consList) 2 | 3 | consList 4 | ( a::b::c 5 | , a{- 1 -}::{- 2 -}b{- 3 -}::{- 4 -}c 6 | , d 7 | :: 8 | e 9 | :: 10 | f 11 | ) 12 | = 13 | () 14 | 15 | 16 | complexCons (a::(x::[])::((b::_)as blah)) = 17 | () 18 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/QuickCheck-94f37da84c1310f03dcfa1059ce870b73c94a825--6449652945938213463.formatted.elm: -------------------------------------------------------------------------------- 1 | module {- A -} Main {- A -} exposing (..) 2 | 3 | 4 | foo = 5 | {- A -} 6 | {- B -} 7 | --A 8 | ( a 9 | , --A 10 | b 11 | , c {- A -} 12 | ) 13 | 14 | 15 | 16 | --A 17 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.19/ListDocumentedExportsNoExposing.elm: -------------------------------------------------------------------------------- 1 | module ListDocumentedExportsNoExposing 2 | 3 | {-| 4 | 5 | @docs a 6 | 7 | # Heading 8 | 9 | @docs X 10 | @docs Y 11 | @docs b, c 12 | 13 | -} 14 | 15 | type alias X = () 16 | type Y = Y1 | Y2 17 | q = 4 18 | a = 1 19 | b = 2 20 | c = 3 21 | p = 5 22 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/CodeBlocksInLists.html: -------------------------------------------------------------------------------- 1 |-
2 |
list item 3 | code
4 | list item
5 |code 6 |
7 | code 8 |
9 | code 10 |
11 | code 12 | code 13 |
14 |
-
2 |
- one 3 |
- one 4 |
-
6 |
- two 7 |
- two 8 |
-
10 |
- three 11 |
- three 12 |
-
14 |
- four 15 |
- four 16 |
-
18 |
- five 19 |
- five 20 |
2 |
6 |
3 | *raw html*
4 |
5 |
7 |
11 |
13 |
16 |
8 |
10 | this is markdown
9 |
17 | * raw html with trailing space
18 |
19 |
--------------------------------------------------------------------------------
/tests/test-files/from-json/Elm-0.19/Simple.json:
--------------------------------------------------------------------------------
1 | {
2 | "moduleName": "Simple",
3 | "body": [
4 | {
5 | "tag": "Definition",
6 | "name": "f",
7 | "parameters": [],
8 | "expression": {
9 | "tag": "UnitLiteral"
10 | }
11 | }
12 | ]
13 | }
14 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Headers/ATX.markdown:
--------------------------------------------------------------------------------
1 | # One
2 | ## Two
3 | ### Three
4 | #### Four
5 | ##### Five
6 |
7 | ###### Six
8 |
9 | ####### Seven
10 |
11 | ### Three with ###
12 | ## Spacing doesn't matter ##
13 | ## Escaped final \##
14 |
15 | \## Not a header
16 |
17 | #5 not a header
18 |
19 | ##
20 | (empty header)
21 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Lists/Sublists.markdown:
--------------------------------------------------------------------------------
1 | Four levels:
2 |
3 | - one
4 | - two
5 | - three
6 | - four
7 |
8 |
9 | 1. one
10 | 1. two
11 | 1. three
12 | 1. four
13 |
14 |
15 | 1) one
16 | - two
17 | 1) three
18 | - four
19 |
20 |
21 | - one
22 | - two
23 | 1. three
24 | 1) four
25 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/HTML/Blocks.markdown:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
3 | *raw html*
4 |
5 |
8 |
14 |
15 |
17 |
18 |
23 |
24 |
9 |
10 | *this is markdown*
11 |
12 |
13 |
25 | * raw html with trailing space
26 |
27 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Headers/ATX.html:
--------------------------------------------------------------------------------
1 | One
2 |Two
3 |Three
4 |Four
5 |Five
6 |Six
7 |####### Seven
8 |Three with
9 |Spacing doesn't matter
10 |Escaped final #
11 |## Not a header
12 |#5 not a header
13 | 14 |(empty header)
15 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Auto_links.markdown: -------------------------------------------------------------------------------- 1 | Link:a
2 | z
4 | a
6 | a
7 | a
8 | a
9 | -
11 |
foo
12 |Hello 13 | 14 | ``` 15 | 16 | World 17 |
18 |
20 |23 | -------------------------------------------------------------------------------- /tests/test-files/CommonMark/.editorconfig: -------------------------------------------------------------------------------- 1 | # editorconfig.org 2 | 3 | root = true 4 | 5 | [*] 6 | end_of_line = lf 7 | charset = utf-8 8 | insert_final_newline = true 9 | 10 | [*.{c,h}] 11 | trim_trailing_whitespace = true 12 | indent_style = tab 13 | indent_size = 8 14 | 15 | [Makefile] 16 | trim_trailing_whitespace = true 17 | indent_style = tab 18 | indent_size = 8 19 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/QuickCheck-4562ebccb71ea9f622fb99cdf32b2923f6f9d34f-2529668492575674138.formatted.elm: -------------------------------------------------------------------------------- 1 | module 2 | --A 3 | Main 4 | {- A -} exposing 5 | ( a 6 | , b 7 | --A 8 | , --A 9 | c 10 | ) 11 | 12 | 13 | foo = 14 | {- A -} 15 | {- B -} 16 | "ABC" ({- A -} {- B -}) {- A -} {- B -} "ABC" () 1 17 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.19/ListAllExportsNoModuleLine.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (X, Y(..), a, b, c, p, q) 2 | 3 | 4 | type alias X = 5 | () 6 | 7 | 8 | type Y 9 | = Y1 10 | | Y2 11 | 12 | 13 | q = 14 | 4 15 | 16 | 17 | a = 18 | 1 19 | 20 | 21 | b = 22 | 2 23 | 24 | 25 | c = 26 | 3 27 | 28 | 29 | p = 30 | 5 31 | -------------------------------------------------------------------------------- /Shakefile/src/Shakefiles/Prelude.hs: -------------------------------------------------------------------------------- 1 | module Shakefiles.Prelude where 2 | 3 | import Development.Shake 4 | 5 | 6 | nTimes :: Int -> (a -> a) -> (a -> a) 7 | nTimes 0 _ = id 8 | nTimes 1 f = f 9 | nTimes n f = f . nTimes (n-1) f 10 | 11 | 12 | hashNeed :: [FilePath] -> Action String 13 | hashNeed files = do 14 | need files 15 | liftIO $ getHashedShakeVersion files 16 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Code/Inline.html: -------------------------------------------------------------------------------- 1 |22 |a 21 |
All of these are equivalent:
2 |-
3 |
*hi*
4 | *hi*
5 | *hi*
6 | *hi*
7 | *hi*
8 |
Backticks in code spans:
10 |-
11 |
``code``
12 | ``code``
13 |
-
2 |
one
3 | two
4 |
-
6 |
- new list 7 |
9 |17 |10 |
13 |- 11 |
one
- 12 |
two
14 |
16 |- new list
15 |
-
18 |
- one 19 |
code
21 | code block on the first line
2 | Regular text.
4 |code block indented by spaces
5 | Regular text.
7 |the lines in this block
8 | all contain trailing spaces
9 | Regular Text.
11 |code block on the last line
12 | 2 |7 |3 |
6 |- tight
4 |- tight
5 |
8 |13 |9 |
12 |- 10 |
loose
- 11 |
loose
14 |18 |15 |
17 |- one-item list
16 |
19 |23 | -------------------------------------------------------------------------------- /elm-format-lib/src/ElmFormat/AST/PublicAST.hs: -------------------------------------------------------------------------------- 1 | module ElmFormat.AST.PublicAST 2 | ( module ElmFormat.AST.PublicAST.Core 3 | , module ElmFormat.AST.PublicAST.Config 4 | , module ElmFormat.AST.PublicAST.Module 5 | ) where 6 | 7 | import ElmFormat.AST.PublicAST.Core (ToPublicAST(..), FromPublicAST(..)) 8 | import ElmFormat.AST.PublicAST.Config 9 | import ElmFormat.AST.PublicAST.Module (fromModule, toModule) 10 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Blockquotes/Separation.markdown: -------------------------------------------------------------------------------- 1 | One blockquote, two paragraphs: 2 | 3 | > one 4 | > 5 | > two 6 | 7 | Two blockquotes: 8 | 9 | > one 10 | 11 | > two 12 | 13 | Nested blockquote, two paragraphs: 14 | 15 | > > one 16 | > > 17 | > > two 18 | 19 | Nested blockquote, two blockquotes: 20 | 21 | > > one 22 | > 23 | > > two 24 | 25 | Two nested blockquotes: 26 | 27 | > > one 28 | 29 | > > two 30 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Links/InlineLinks.html: -------------------------------------------------------------------------------- 1 |20 |
22 |- one-item list
21 |
-
2 |
- link 3 |
- link 4 |
- link 5 |
- link with 7 | linebreak. 8 |
- link 9 |
- [not a link] (/url) 10 |
not a tag 5 | \[link](/foo) not a link 6 | [link](/foo\) "title\"") 7 | \`not code` 8 | 9 | 1\. not a list item 10 | 11 | \* not a list. 12 | 13 | \# Not a header 14 | 15 | \[foo]: /url "not a reference" 16 | 17 | \$ \^ \; can be escaped. 18 | \a \b \T cannot. 19 | unicode letters and symbols cannot: \π \‥. 20 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Misc/Laziness.html: -------------------------------------------------------------------------------- 1 |
2 |7 |3 |
6 |- one 4 | two
5 |
Laziness only affects paragraph continuations:
8 |9 |12 |11 |code 10 |
not same code block
13 | -
15 |
- hello 16 |
18 |
19 |22 | -------------------------------------------------------------------------------- /tests/test-files/CommonMark/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "commonmark-spec", 3 | "version": "0.27.0", 4 | "description": "CommonMark spec and test cases", 5 | "homepage": "http://commonmark.org", 6 | "license": "CC-BY-SA-4.0", 7 | "keywords": [ 8 | "commonmark", 9 | "markdown" 10 | ], 11 | "repository": "jgm/CommonMark", 12 | "license": "MIT", 13 | "files": [ 14 | "index.js", 15 | "spec.txt" 16 | ] 17 | } 18 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/WindowsEol.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.WindowsEol exposing (string) 2 | 3 | {-| elm-format converts all CRLF line-endings to LF. 4 | 5 | Raw CRs that are within strings will be escaped. 6 | 7 | Escaped CRs will be retained. 8 | -} 9 | 10 | 11 | multilineString = 12 | """ 13 | """ 14 | 15 | 16 | string = " 17 | " 18 | 19 | 20 | rawCR = " " 21 | 22 | 23 | escapedCR = "\x0D" 24 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Generated source files 2 | /generated/ 3 | 4 | # Files generated by the test suite 5 | /formatted.elm 6 | /_input.elm 7 | /_input2.elm 8 | /_stdout.txt 9 | /tests/**/actual 10 | 11 | # Files generated by the build system 12 | /.direnv/ 13 | /.shake/ 14 | /.shake.cache/ 15 | /_build/ 16 | /dist-newstyle/ 17 | /bin/ 18 | 19 | # Output files 20 | /dist/ 21 | /publish/ 22 | /downloads/ 23 | /result 24 | /_profile/ 25 | /_coverage/ 26 | -------------------------------------------------------------------------------- /parser/tests/test-files/bad/IncompletePatternMatch.elm: -------------------------------------------------------------------------------- 1 | 2 | type List a 3 | = Nil 4 | | Cons a (List a) 5 | 6 | 7 | zip : List a -> List b -> List (a, b) 8 | zip list1 list2 = 9 | case (list1, list2) of 10 | (Nil, _) -> 11 | Nil 12 | 13 | (Cons x xs, Cons y ys) -> 14 | Cons (x, y) (zip xs ys) 15 | 16 | -- incomplete pattern match is an error 17 | -- missing: (_, Nil) -> Nil 18 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.17/AllSyntax/BlockComments/ModuleEffect.elm: -------------------------------------------------------------------------------- 1 | effect {- T -} module {- A -} AllSyntax.BlockComments.ModuleEffect {- B -} where {- C -} { {- D -} command {- E -} = {- F -} MyCmd {- G -}, {- H -} subscription {- I -} = {- J -} MySub {- K -} } {- L -} exposing {- M -} ({- N -} a {- O -}, {- P -} b {- Q -}, {- R -} c {- S -}) 2 | 3 | 4 | type MyCmd msg 5 | = MyCmd msg 6 | 7 | 8 | type MySub msg 9 | = MySub msg 10 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Tabs.markdown: -------------------------------------------------------------------------------- 1 | + this is a list item 2 | indented with tabs 3 | 4 | + this is a list item 5 | indented with spaces 6 | 7 | Code: 8 | 9 | this code block is indented by one tab 10 | 11 | And: 12 | 13 | this code block is indented by two tabs 14 | 15 | And: 16 | 17 | + this is an example list item 18 | indented with tabs 19 | 20 | + this is an example list item 21 | indented with spaces 22 | -------------------------------------------------------------------------------- /parser/tests/test-files/good/Ports.elm: -------------------------------------------------------------------------------- 1 | 2 | -- incoming 3 | port userID : String 4 | port number : Int 5 | port tuple : (Float,Bool) 6 | port array : List Int 7 | port record : { x:Float, y:Float } 8 | 9 | -- outgoing 10 | port fortyTwo : Int 11 | port fortyTwo = 12 | 42 13 | 14 | 15 | port time : Float 16 | port time = 17 | 3.14 18 | 19 | port students : List { name:String, age:Int } 20 | port students = 21 | [ { name = "Tom", age = 42 } ] -------------------------------------------------------------------------------- /tests/json-format-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "array", 3 | "items": { 4 | "type": "object", 5 | "properties": { 6 | "path": { 7 | "type": "string" 8 | }, 9 | "line": { 10 | "type": "number" 11 | }, 12 | "column": { 13 | "type": "number" 14 | }, 15 | "message": { 16 | "type": "string" 17 | } 18 | }, 19 | "required": ["path", "message"] 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Misc/LineBreaks.html: -------------------------------------------------------------------------------- 1 |21 |code 20 |
Two spaces
2 | break a line. Or more than two
3 | and spaces in the following line are absorbed.
You can also break lines with
5 | a backslash.
Two spaces at the end of a paragraph are 7 | not a line break.
8 |A backslash at the end of a paragraph is 9 | not a line break.\
10 |Similarly with setext headers
11 |And with backslashes\
12 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/WindowsEol.formatted.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.WindowsEol exposing (string) 2 | 3 | {-| elm-format converts all CRLF line-endings to LF. 4 | 5 | Raw CRs that are within strings will be escaped. 6 | 7 | Escaped CRs will be retained. 8 | 9 | -} 10 | 11 | 12 | multilineString = 13 | """ 14 | """ 15 | 16 | 17 | string = 18 | "\n" 19 | 20 | 21 | rawCR = 22 | "\x0D" 23 | 24 | 25 | escapedCR = 26 | "\x0D" 27 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Links/ParensInURLs.markdown: -------------------------------------------------------------------------------- 1 | [Inline link 1 with parens](/url\(test\) "title"). 2 | 3 | [Inline link 2 with parens]( "title"). 4 | 5 | [Inline link 3 with non-escaped parens](/url(test) "title"). 6 | 7 | [Inline link 4 with non-escaped parens]( "title"). 8 | 9 | [Reference link 1 with parens][1]. 10 | 11 | [Reference link 2 with parens][2]. 12 | 13 | [1]: /url(test) "title" 14 | [2]: "title" 15 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/MultipleBlankLines.markdown: -------------------------------------------------------------------------------- 1 | 1. First Item 2 | 3 | * one 4 | * two 5 | 6 | * one 7 | * two 8 | 9 | 1. Second Item 10 | 11 | * one 12 | * two 13 | 14 | 15 | * one 16 | * two 17 | 18 | 1. Third Item 19 | 20 | * one 21 | * two 22 | 23 | 24 | 25 | * one 26 | * two 27 | 28 | 1. Fourth Item 29 | 30 | * one 31 | * two 32 | 33 | 34 | 35 | 36 | * one 37 | * two 38 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.17/AllSyntax/OldKeywords.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.OldKeywords exposing (OldKeywords, deriving, foreign, hiding) 2 | 3 | 4 | type alias OldKeywords = 5 | { foreign : Int 6 | , hiding : Bool 7 | , deriving : String 8 | } 9 | 10 | 11 | foreign : Float 12 | foreign = 13 | 0 14 | 15 | 16 | hiding : Int -> Int 17 | hiding x = 18 | x + 1 19 | 20 | 21 | deriving : Maybe OldKeywords 22 | deriving = 23 | Nothing 24 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/OldKeywords.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.OldKeywords exposing (OldKeywords, deriving, foreign, hiding) 2 | 3 | 4 | type alias OldKeywords = 5 | { foreign : Int 6 | , hiding : Bool 7 | , deriving : String 8 | } 9 | 10 | 11 | foreign : Float 12 | foreign = 13 | 0 14 | 15 | 16 | hiding : Int -> Int 17 | hiding x = 18 | x + 1 19 | 20 | 21 | deriving : Maybe OldKeywords 22 | deriving = 23 | Nothing 24 | -------------------------------------------------------------------------------- /dev/Documentation/Build Commands.md: -------------------------------------------------------------------------------- 1 | 2 | - `dev/build.sh`: build and run tests 3 | - `dev/build.sh build`: build a local binary to `./_build/elm-format` 4 | - `dev/build.sh ci`: run all build targets that are checked on CI 5 | - `dev/build.sh coverage`: write coverage report to `_coverage/*/*.txt` 6 | - `dev/build.sh serve:docs`: start a local HTTP server with the public Haskell API docs 7 | - `dev/build.sh serve:coverage`: start a local HTTP server with code coverage reports 8 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Misc/BackslashEscapes.html: -------------------------------------------------------------------------------- 1 |*not emphasized* 2 | \emphasis 3 | **not bold** 4 | <br/> not a tag 5 | [link](/foo) not a link 6 | link 7 | `not code`
8 |1. not a list item
9 |* not a list.
10 |# Not a header
11 |[foo]: /url "not a reference"
12 |$ ^ ; can be escaped. 13 | \a \b \T cannot. 14 | unicode letters and symbols cannot: \π \‥.
15 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.19/GLShader.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.GLShader exposing (vertexShader) 2 | 3 | 4 | vertexShader : Shader { position : Vec3, coord : Vec3 } { u | view : Mat4 } { vcoord : Vec2 } 5 | vertexShader = 6 | [glsl| 7 | 8 | attribute vec3 position; 9 | attribute vec3 coord; 10 | uniform mat4 view; 11 | varying vec2 vcoord; 12 | 13 | void main () { 14 | gl_Position = view * vec4(position, 1.0); 15 | vcoord = coord.xy; 16 | } 17 | 18 | |] 19 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/MissingImportParens.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (x) 2 | 3 | import Import.As1 as ImportAs1 4 | import Import.As2 as ImportAs2 exposing (A) 5 | import ImportDotDot exposing (..) 6 | import ImportName exposing (A) 7 | import ImportNames exposing (A, B, x, y) 8 | import ImportNamesLineBreak exposing (A, B) 9 | import MergeImport exposing (A, B, Z) 10 | import OtherImport exposing (A(X, Y), b, z) 11 | 12 | 13 | x = 14 | () 15 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Code/BlankLines.html: -------------------------------------------------------------------------------- 1 |foo
2 |
3 |
4 |
5 | bar
6 | 8 |15 |14 |foo 9 | 10 | 11 | 12 | bar 13 |
foo
16 |
17 |
18 |
19 | bar
20 | -
22 |
One
23 |CodeA 24 | 25 | CodeB 26 |
27 | Two
28 |CodeA 29 |
30 |
-
32 |
- One 33 |
2 |7 |blockquote
3 |4 |6 |blockquote
5 |
-
8 |
- list 9 |
- list
10 |
-
11 |
- sublist 12 |
13 |
15 |
paragraph
16 |header
17 |header
18 |code
19 | code
21 |
23 |
27 |
--------------------------------------------------------------------------------
/tests/test-files/good/Elm-0.18/AllSyntax/GLShader.elm:
--------------------------------------------------------------------------------
1 | module AllSyntax.GLShader exposing (vertexShader)
2 |
3 |
4 | vertexShader : Shader { position : Vec3, coord : Vec3 } { u | view : Mat4 } { vcoord : Vec2 }
5 | vertexShader =
6 | [glsl|
7 |
8 | attribute vec3 position;
9 | attribute vec3 coord;
10 | uniform mat4 view;
11 | varying vec2 vcoord;
12 |
13 | void main () {
14 | gl_Position = view * vec4(position, 1.0);
15 | vcoord = coord.xy;
16 | }
17 |
18 | |]
19 |
--------------------------------------------------------------------------------
/parser/bench/elm-package.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": "1.0.0",
3 | "summary": "Benchmarking based on benchmark.js",
4 | "repository": "https://github.com/JoeyEremondi/elm-benchmark.git",
5 | "license": "BSD3",
6 | "source-directories": [
7 | "src"
8 | ],
9 | "exposed-modules": [],
10 | "native-modules": true,
11 | "dependencies": {
12 | "elm-lang/core": "2.1.0 <= v < 3.0.0"
13 | },
14 | "elm-version": "0.15.1 <= v < 0.16.0"
15 | }
16 |
--------------------------------------------------------------------------------
/tests/test-files/transform/Elm-0.18/DocCommentAtDocs.elm:
--------------------------------------------------------------------------------
1 | module DocCommentAtDocs exposing (x, y, z, T(..))
2 |
3 | {-|
4 |
5 | @docs
6 | x,
7 | y,
8 | z
9 | @docs T(..)
10 |
11 | @docs a , b , c
12 | @docs d
13 |
14 | Paragraph
15 | @docs startABlock,
16 | moreDocs
17 |
18 | -}
19 |
20 |
21 | {-| X
22 | -}
23 | x : ()
24 | x =
25 | ()
26 |
27 |
28 | {-| Y
29 | -}
30 | y : ()
31 | y =
32 | ()
33 |
34 |
35 | {-| Z
36 | -}
37 | z : ()
38 | z =
39 | ()
40 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Code/IndentedCodeBlocks.markdown:
--------------------------------------------------------------------------------
1 | Indented code with two space indent in first and last line:
2 |
3 | two spaces *hello*
4 | { more }
5 |
6 | and
7 |
8 | Indented code requires a leading/trailing blank line:
9 | quick-command --option "$*"
10 |
11 | Indented code does not require a trailing blank line:
12 |
13 | code
14 | and not code.
15 |
16 | Code in blockquote:
17 |
18 | > code
19 |
20 | Code in list:
21 |
22 | 1. code
23 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Code/IndentedInLists.html:
--------------------------------------------------------------------------------
1 |
24 | # not a header
25 |
26 | -
2 |
code starts here 3 |
4 |
-
6 |
foo
7 |code starts here 8 |
9 | foo
10 |code starts here 11 |
12 |
-
14 |
foo
15 |
17 |code starts here 16 |-
18 |
foo
19 |code starts here 20 |
21 |
22 |
http://google.com?query=blah&time=15 2 | someone.else@somedomain.com 3 | ftp://old.ftp.server.edu 4 | git://some.git.repo/project.git 5 | <not autolink> 6 | <http://not.an autolink> 7 | <relative/not/autolink>
8 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/MissingImportParens.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (x) 2 | 3 | import OtherImport exposing (A(X, Y), b, z) 4 | import Import.As1 as ImportAs1 5 | import Import.As2 as ImportAs2 exposing A 6 | import ImportDotDot exposing .. 7 | import ImportName exposing A 8 | import ImportNames exposing A, B, x, y 9 | import ImportNamesLineBreak exposing 10 | A, B 11 | import MergeImport exposing (Z) 12 | import MergeImport exposing A, B 13 | 14 | 15 | x = 16 | () 17 | -------------------------------------------------------------------------------- /.github/actions/cache-haskell-deps/action.yml: -------------------------------------------------------------------------------- 1 | inputs: 2 | cabal-store: 3 | required: false 4 | default: ~/.cabal/store 5 | runs: 6 | using: "composite" 7 | steps: 8 | - name: Cache ~/.cabal/store 9 | uses: actions/cache@v3 10 | with: 11 | path: ${{ inputs.cabal-store }} 12 | key: cabal-v3-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('cabal.project.freeze') }} 13 | restore-keys: | 14 | cabal-v3-${{ runner.os }}-${{ runner.arch }}- 15 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/TightAndLoose.markdown: -------------------------------------------------------------------------------- 1 | 1. tight 2 | 3 | 4 | - tight 5 | - list 6 | 7 | 8 | - loose 9 | 10 | - list 11 | 12 | 13 | 1. tight 14 | 2. list 15 | 16 | 17 | 1. loose 18 | 19 | 2. list 20 | 21 | 22 | 1. loose 23 | 24 | - sublist 25 | 26 | 27 | 28 | 1. tight 29 | - sublist 30 | 31 | 32 | - tight 33 | > blockquote 34 | and 35 | ``` 36 | code 37 | ``` 38 | - tight 39 | 40 | 41 | - loose 42 | - with loose 43 | 44 | - sublist 45 | - loose 46 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Inline_HTML_Advanced.html: -------------------------------------------------------------------------------- 1 |Simple block on one line:
2 |foo
3 | And nested without indentation:
4 |
5 |
13 |
6 |
11 |
7 | foo
8 |
9 |
10 | bar
12 | And with attributes:
14 |
15 |
18 |
16 |
17 | This was broken in 1.0.2b7:
19 |
20 |
24 |
--------------------------------------------------------------------------------
/tests/test-files/CommonMark/RELEASE_CHECKLIST.md:
--------------------------------------------------------------------------------
1 | Release checklist
2 |
3 | _ update changelog.txt
4 | _ update version in package.json
5 | _ tag release
6 | _ git push
7 | _ git push --tags
8 | _ npm publish
9 | _ update dingus:
10 |
11 | cd ../commonmark.js
12 | cd dingus
13 | make
14 |
15 | _ update site:
16 |
17 | cd ../../CommonMark-site
18 | make update
19 | make
20 | make upload
21 |
22 | _ update babelmark2: copy commonmark.js to src/babelmark2/js on server
23 |
--------------------------------------------------------------------------------
/Shakefile/src/Shakefiles/Extra.hs:
--------------------------------------------------------------------------------
1 | module Shakefiles.Extra (phonyPrefix, forEach) where
2 |
3 | import Development.Shake
4 | import Data.List (stripPrefix)
5 |
6 |
7 | phonyPrefix :: String -> (String -> Action ()) -> Rules ()
8 | phonyPrefix prefix action =
9 | phonys $ \s -> case stripPrefix prefix s of
10 | Nothing -> Nothing
11 | Just match -> Just (action match)
12 |
13 |
14 |
15 | forEach :: Monad m => [a] -> (a -> m ()) -> m ()
16 | forEach list f =
17 | mapM_ f list
18 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Misc/LineBreaks.markdown:
--------------------------------------------------------------------------------
1 | Two spaces
2 | break a line. Or more than two
3 | and spaces in the following line are absorbed.
4 |
5 | You can also break lines with\
6 | a backslash.
7 |
8 | Two spaces at the end of a paragraph are
9 | not a line break.
10 |
11 | A backslash at the end of a paragraph is
12 | not a line break.\
13 |
14 | Similarly with setext headers
15 | -------------------------------
16 |
17 | And with backslashes\
18 | ---------------------
19 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Original/Inline_HTML_Advanced.markdown:
--------------------------------------------------------------------------------
1 | Simple block on one line:
2 |
3 |
21 | foo
22 |
23 | foo
4 |
5 | And nested without indentation:
6 |
7 |
8 |
16 |
17 | And with attributes:
18 |
19 |
9 |
14 |
10 | foo
11 |
12 |
13 | bar
15 |
20 |
23 |
24 | This was broken in 1.0.2b7:
25 |
26 |
21 |
22 |
27 |
31 |
--------------------------------------------------------------------------------
/Style Guide/Declarations.md:
--------------------------------------------------------------------------------
1 | # Declarations
2 |
3 |
4 |
5 |
6 | ## Infix operators
7 |
8 | Avoid infix operators when possible and prefer using named functions.
9 |
10 | Infix operator declartions should prefer the following ordering:
11 | documentation comment,
12 | infix properties (if not the default),
13 | type annotation,
14 | definition.
15 |
16 | ```elm
17 | {-| Documentation
18 | -}
19 | infixr 5 ::?
20 | (::?) : Maybe a -> List a -> List a
21 | (::?) elem list =
22 | list
23 | ```
24 |
--------------------------------------------------------------------------------
/tests/test-files/good/Elm-0.17/WorkaroundNegativeCasePatterns.elm:
--------------------------------------------------------------------------------
1 | module MinusErr exposing (errFloats, errInts)
2 |
3 |
4 | errInts : Int -> Int
5 | errInts x =
6 | case x of
7 | (-1) ->
8 | 0
9 |
10 | (-2) ->
11 | 0
12 |
13 | _ ->
14 | 1
15 |
16 |
17 | errFloats : Float -> Float
18 | errFloats x =
19 | case x of
20 | (-1.0) ->
21 | 0
22 |
23 | (-2.1) ->
24 | 0
25 |
26 | _ ->
27 | 1
28 |
--------------------------------------------------------------------------------
/tests/test-files/good/Elm-0.18/WorkaroundNegativeCasePatterns.elm:
--------------------------------------------------------------------------------
1 | module MinusErr exposing (errFloats, errInts)
2 |
3 |
4 | errInts : Int -> Int
5 | errInts x =
6 | case x of
7 | (-1) ->
8 | 0
9 |
10 | (-2) ->
11 | 0
12 |
13 | _ ->
14 | 1
15 |
16 |
17 | errFloats : Float -> Float
18 | errFloats x =
19 | case x of
20 | (-1.0) ->
21 | 0
22 |
23 | (-2.1) ->
24 | 0
25 |
26 | _ ->
27 | 1
28 |
--------------------------------------------------------------------------------
/tests/test-files/good/Elm-0.19/WorkaroundNegativeCasePatterns.elm:
--------------------------------------------------------------------------------
1 | module MinusErr exposing (errFloats, errInts)
2 |
3 |
4 | errInts : Int -> Int
5 | errInts x =
6 | case x of
7 | (-1) ->
8 | 0
9 |
10 | (-2) ->
11 | 0
12 |
13 | _ ->
14 | 1
15 |
16 |
17 | errFloats : Float -> Float
18 | errFloats x =
19 | case x of
20 | (-1.0) ->
21 | 0
22 |
23 | (-2.1) ->
24 | 0
25 |
26 | _ ->
27 | 1
28 |
--------------------------------------------------------------------------------
/elm-format-markdown/tests/Links/ParensInURLs.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
28 | foo
29 |
30 | Inline link 3 with non-escaped parens.
4 |Inline link 4 with non-escaped parens.
5 | 6 | 7 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/DocCommentCodeExample.elm: -------------------------------------------------------------------------------- 1 | module DocCommentCodeExample exposing (f) 2 | 3 | {-| -} 4 | 5 | 6 | {-| Compute with f (indented code block) 7 | 8 | myValue = f 20 9 | -} 10 | f x = 11 | x * x 12 | 13 | 14 | {-| Compute with g (backticks code block) 15 | 16 | ``` 17 | myValue = g 99 18 | ``` 19 | -} 20 | g y = 21 | y + (4 * y) 22 | 23 | 24 | {-| Format expressions in code blocks 25 | 26 | h 20 --> 21 27 | 28 | h 21 --> 22 29 | 30 | -} 31 | h z = 32 | z + 1 33 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Amps_and_angle_encoding.markdown: -------------------------------------------------------------------------------- 1 | AT&T has an ampersand in their name. 2 | 3 | AT&T is another way to write it. 4 | 5 | This & that. 6 | 7 | 4 < 5. 8 | 9 | 6 > 5. 10 | 11 | Here's a [link] [1] with an ampersand in the URL. 12 | 13 | Here's a link with an amersand in the link text: [AT&T] [2]. 14 | 15 | Here's an inline [link](/script?foo=1&bar=2). 16 | 17 | Here's an inline [link](). 18 | 19 | 20 | [1]: http://example.com/?foo=1&bar=2 21 | [2]: http://att.com/ "AT&T" -------------------------------------------------------------------------------- /elm-format-markdown/tests/Code/ListBreakAfter.html: -------------------------------------------------------------------------------- 1 |-
2 |
foo
3 |-
4 |
bar
5 |
8 |code1 6 | code2 7 |code?
9 |
10 | foo
11 |-
12 |
bar
13 |code1 14 | code2 15 |
16 |
17 |
code?
19 | -
21 |
- foo
22 |
-
23 |
bar
24 |code1 25 | code2 26 |
27 |
28 |
code?
30 | -
2 |
this is a list item 3 | indented with tabs
4 | this is a list item 5 | indented with spaces
6 |
Code:
8 |this code block is indented by one tab
9 | And:
11 | this code block is indented by two tabs
12 | And:
14 |+ this is an example list item
15 | indented with tabs
16 |
17 | + this is an example list item
18 | indented with spaces
19 | AT&T has an ampersand in their name.
2 |AT&T is another way to write it.
3 |This & that.
4 |4 < 5.
5 |6 > 5.
6 |Here's a link with an ampersand in the URL.
7 |Here's a link with an amersand in the link text: AT&T.
8 |Here's an inline link.
9 |Here's an inline link.
10 | -------------------------------------------------------------------------------- /parser/bench/src/SmallTupleBench.elm: -------------------------------------------------------------------------------- 1 | module SmallTupleBench where 2 | 3 | type alias SmallTuple = 4 | ( Float 5 | , Float 6 | , Float 7 | , Float 8 | , Float 9 | , Float 10 | , Float 11 | , Float 12 | , Float 13 | ) 14 | 15 | defaultTuple = 16 | (1.0, 2.0, 3.0) 17 | 18 | getField (x1, x2, x3) i = 19 | case (i % 3) of 20 | 1 -> 21 | x1 22 | 2 -> 23 | x2 24 | 0 -> 25 | x3 26 | 27 | 28 | sumRandomElems : List Int -> Float 29 | sumRandomElems randomInts = 30 | List.foldr (\i sumSoFar -> (getField defaultTuple i) + sumSoFar ) 0.0 randomInts -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/Comments.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.Comments exposing (blockComment, indentedMultilineBlockComment, multilineCommentTrickDisabled, nestedBlockComment) 2 | 3 | 4 | blockComment = 5 | {- A -} 6 | () 7 | 8 | 9 | nestedBlockComment = 10 | {- A {- {- C -} B {- D -} -} {- E -} -} 11 | () 12 | 13 | 14 | indentedMultilineBlockComment = 15 | {- A 16 | B 17 | C 18 | -} 19 | () 20 | 21 | 22 | {--} 23 | multilineCommentTrickDisabled = 24 | () 25 | --} 26 | 27 | 28 | 29 | {-- 30 | multilineCommentTrickEnabled = 31 | () 32 | --} 33 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/Examples.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (bar, multilineList, ratio) 2 | 3 | 4 | ratio = 5 | graphHeight 6 | / (if range == 0 then 7 | 0.1 8 | 9 | else 10 | toFloat range 11 | ) 12 | 13 | 14 | 15 | -- foo=(case x of {True->1;False->3}) 16 | 17 | 18 | bar = 19 | if 20 | if a then 21 | True 22 | 23 | else 24 | False 25 | then 26 | "a" 27 | 28 | else 29 | "b" 30 | 31 | 32 | multilineList = 33 | [ 1 34 | , 2 35 | , 3 36 | ] 37 | -------------------------------------------------------------------------------- /avh4-lib/src/Data/Coapplicative.hs: -------------------------------------------------------------------------------- 1 | module Data.Coapplicative (Coapplicative(..)) where 2 | 3 | import Data.Functor.Compose 4 | import Data.Functor.Identity 5 | 6 | 7 | class Functor f => Coapplicative f where 8 | extract :: f a -> a 9 | 10 | instance Coapplicative ((,) x) where 11 | extract (_, a) = a 12 | {-# INLINE extract #-} 13 | 14 | instance Coapplicative Identity where 15 | extract = runIdentity 16 | {-# INLINE extract #-} 17 | 18 | instance (Coapplicative a, Coapplicative b) => Coapplicative (Compose a b) where 19 | extract = extract . extract . getCompose 20 | {-# INLINE extract #-} 21 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Horizontal_rules.html: -------------------------------------------------------------------------------- 1 |Dashes:
2 |3 |
4 |
5 |
6 |
---
7 | 9 |
10 |
11 |
12 |
- - -
13 | Asterisks:
15 |16 |
17 |
18 |
19 |
***
20 | 22 |
23 |
24 |
25 |
* * *
26 | Underscores:
28 |29 |
30 |
31 |
32 |
___
33 | 35 |
36 |
37 |
38 |
_ _ _
39 | -
2 |
- tight I
3 |
4 |
bq
5 |
6 | - tight I 7 |
-
9 |
- tight II
10 |
11 |
13 | foobq
12 |
14 | - tight II 15 |
-
17 |
- Blank lines in bq don't break list
18 |
19 |
bq
20 |
21 | - Should say (2) in output 22 |
-
24 |
- Blank lines in bq don't break LI
25 |
-
26 |
- item A
27 |
28 |
bq
29 |
30 | - item B 31 |
32 | - item A
27 |
Link: http://example.com/.
2 |With an ampersand: http://example.com/?foo=1&bar=2
3 |-
4 |
- In a list? 5 |
- http://example.com/ 6 |
- It should. 7 |
9 |11 |Blockquoted: http://example.com/
10 |
Auto-links should not occur here: <http://example.com/>
or here: <http://example.com/>
13 | Indented code with two space indent in first and last line:
2 | two spaces *hello*
3 | { more }
4 |
5 | and
6 | Indented code requires a leading/trailing blank line: 8 | quick-command --option "$*"
9 |Indented code does not require a trailing blank line:
10 |code
11 | and not code.
13 |Code in blockquote:
14 |15 |18 |17 |code 16 |
Code in list:
19 |-
20 |
code 21 |
22 |
These are all equivalent:
2 |3 |8 |4 |7 |nested 5 | blockquote
6 |
9 |14 |10 |13 |nested 11 | blockquote
12 |
15 |20 |16 |19 |nested 17 | blockquote
18 |
21 |26 |22 |25 |nested 23 | blockquote
24 |
This is not:
27 |28 |33 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Horizontal_rules.markdown: -------------------------------------------------------------------------------- 1 | Dashes: 2 | 3 | --- 4 | 5 | --- 6 | 7 | --- 8 | 9 | --- 10 | 11 | --- 12 | 13 | - - - 14 | 15 | - - - 16 | 17 | - - - 18 | 19 | - - - 20 | 21 | - - - 22 | 23 | 24 | Asterisks: 25 | 26 | *** 27 | 28 | *** 29 | 30 | *** 31 | 32 | *** 33 | 34 | *** 35 | 36 | * * * 37 | 38 | * * * 39 | 40 | * * * 41 | 42 | * * * 43 | 44 | * * * 45 | 46 | 47 | Underscores: 48 | 49 | ___ 50 | 51 | ___ 52 | 53 | ___ 54 | 55 | ___ 56 | 57 | ___ 58 | 59 | _ _ _ 60 | 61 | _ _ _ 62 | 63 | _ _ _ 64 | 65 | _ _ _ 66 | 67 | _ _ _ 68 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.19/AllSyntax/Module.json-roundtrip: -------------------------------------------------------------------------------- 1 | module AllSyntax.Module exposing (CustomType(..), a, b, c) 2 | 3 | import Dict as D exposing (Dict, empty, fromList) 4 | import Json.Decode as Json 5 | import Maybe exposing (Maybe(..), map) 6 | import Result exposing (Result(..)) 7 | import Signal exposing (..) 8 | import String 9 | import Task exposing (andMap, andThen, fail, fromMaybe, fromResult, map, map2, map3, map4, map5, mapError, onError, succeed, toMaybe, toResult) 10 | 11 | 12 | type CustomType 13 | = TagA 14 | | TagB 15 | 16 | 17 | a = 18 | 1 19 | 20 | 21 | b = 22 | 2 23 | 24 | 25 | c = 26 | 3 27 | -------------------------------------------------------------------------------- /tests/Test.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import Test.Tasty 4 | import Test.Tasty.Hspec (testSpec) 5 | 6 | import qualified Test.Property 7 | -- import qualified CommonMarkTests 8 | import qualified Integration.CliTest 9 | import qualified Integration.LiteralTest 10 | 11 | 12 | main :: IO () 13 | main = 14 | do 15 | -- markdownTests <- CommonMarkTests.construct 16 | spec <- testSpec "" Integration.CliTest.spec_spec 17 | defaultMain $ testGroup "elm-format" $ 18 | [ Test.Property.propertyTests 19 | , spec 20 | , Integration.LiteralTest.tests 21 | -- , markdownTests 22 | ] 23 | -------------------------------------------------------------------------------- /.github/actions/cache-build/action.yml: -------------------------------------------------------------------------------- 1 | runs: 2 | using: "composite" 3 | steps: 4 | - name: Cache .shake.cache 5 | uses: actions/cache@v3 6 | with: 7 | path: .shake.cache 8 | key: shake-v1-${{ runner.os }}-${{ runner.arch }}-${{ github.run_id }} 9 | restore-keys: | 10 | shake-v1-${{ runner.os }}-${{ runner.arch }}- 11 | - name: Cache dist-newstyle 12 | uses: actions/cache@v3 13 | with: 14 | path: dist-newstyle 15 | key: cabal-dist-v1-${{ runner.os }}-${{ runner.arch }}-${{ github.run_id }} 16 | restore-keys: | 17 | cabal-dist-v1-${{ runner.os }}-${{ runner.arch }}- 18 | -------------------------------------------------------------------------------- /tests/test-files/from-json/Elm-0.19/ModuleComments.json: -------------------------------------------------------------------------------- 1 | { 2 | "moduleName": "ModuleComments", 3 | "body": [ 4 | { 5 | "tag": "Comment", 6 | "text": " Default comment" 7 | }, 8 | { 9 | "tag": "Comment", 10 | "text": "Block comment", 11 | "display": { 12 | "commentType": "BlockComment" 13 | } 14 | }, 15 | { 16 | "tag": "Definition", 17 | "name": "f", 18 | "parameters": [], 19 | "expression": { 20 | "tag": "UnitLiteral" 21 | } 22 | } 23 | ] 24 | } 25 | -------------------------------------------------------------------------------- /avh4-lib/src/Data/Either/Extra.hs: -------------------------------------------------------------------------------- 1 | module Data.Either.Extra (collectErrors) where 2 | 3 | import Prelude () 4 | import Relude 5 | 6 | 7 | collectErrors :: [Either l r] -> Either [l] [r] 8 | collectErrors list = 9 | let 10 | step acc next = 11 | case (next, acc) of 12 | (Left l, Right _) -> 13 | Left [l] 14 | 15 | (Left l, Left ls) -> 16 | Left (l : ls) 17 | 18 | (Right r, Right rs) -> 19 | Right (r : rs) 20 | 21 | (Right _, Left ls) -> 22 | Left ls 23 | in 24 | foldl' step (Right []) list 25 | -------------------------------------------------------------------------------- /.gitpod.yml: -------------------------------------------------------------------------------- 1 | 2 | tasks: 3 | - before: | 4 | export GHCUP_INSTALL_BASE_PREFIX=/workspace/.ghcup 5 | export CABAL_DIR=/workspace/.cabal 6 | source "$GHCUP_INSTALL_BASE_PREFIX/.ghcup/env" || true 7 | init: | 8 | curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh 9 | source "$GHCUP_INSTALL_BASE_PREFIX/.ghcup/env" 10 | ghcup install ghc 9.6.7 11 | ghcup set ghc 9.6.7 12 | ghcup install cabal 13 | cabal update 14 | ./dev/build.sh 15 | command: ./_build/elm-format 16 | 17 | vscode: 18 | extensions: 19 | - haskell.haskell 20 | -------------------------------------------------------------------------------- /.github/workflows/Touch cache.yml: -------------------------------------------------------------------------------- 1 | name: Touch cache 2 | 3 | on: 4 | schedule: 5 | - cron: "16 11 * * 3,6" 6 | 7 | defaults: 8 | run: 9 | shell: bash 10 | 11 | jobs: 12 | build: 13 | strategy: 14 | matrix: 15 | os: 16 | - ubuntu-latest 17 | - windows-latest 18 | # - macOS-latest 19 | 20 | name: touch-cache-${{ matrix.os }} 21 | runs-on: ${{ matrix.os }} 22 | 23 | steps: 24 | - name: Configure environment 25 | run: | 26 | git config --global core.autocrlf false 27 | - uses: actions/checkout@v3 28 | - uses: ./.github/actions/cache-haskell-deps 29 | - uses: ./.github/actions/cache-build 30 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/Sublists.html: -------------------------------------------------------------------------------- 1 |nested
29 |30 |32 |blockquote
31 |
Four levels:
2 |-
3 |
- one
4 |
-
5 |
- two
6 |
-
7 |
- three
8 |
-
9 |
- four 10 |
11 |
12 | - three
8 |
13 | - two
6 |
-
15 |
- one
16 |
-
17 |
- two
18 |
-
19 |
- three
20 |
-
21 |
- four 22 |
23 |
24 | - three
20 |
25 | - two
18 |
-
27 |
- one
28 |
-
29 |
- two
30 |
-
31 |
- three
32 |
-
33 |
- four 34 |
35 |
36 | - three
32 |
37 | - two
30 |
-
39 |
- one
40 |
-
41 |
- two
42 |
-
43 |
- three
44 |
-
45 |
- four 46 |
47 |
48 | - three
44 |
49 | - two
42 |
Here is a _ that is cool.
2 |Foo.
3 |Foo.
4 |Foo.
5 |Foo.
6 |Foo.
7 |Foo.
8 |Foo. Foo? Foo! Foo: Foo; (Foo)
9 |Foo. Foo? Foo! Foo: Foo; (Foo)
10 |Foo. Foo? Foo! Foo: Foo; (Foo)
11 | -------------------------------------------------------------------------------- /avh4-lib/src/Data/ReversedList.hs: -------------------------------------------------------------------------------- 1 | module Data.ReversedList where 2 | 3 | {-| 4 | ReversedList can be used to avoid accidentally forgetting to reverse a list 5 | (this most commonly occurs when implementing recursive algorithms that build up a 6 | list that needs to be reversed in the termination case). 7 | -} 8 | 9 | newtype Reversed a = Reversed [a] 10 | 11 | 12 | empty :: Reversed a 13 | empty = 14 | Reversed [] 15 | 16 | 17 | push :: a -> Reversed a -> Reversed a 18 | push a (Reversed list) = 19 | Reversed (a : list) 20 | 21 | 22 | isEmpty :: Reversed a -> Bool 23 | isEmpty (Reversed []) = True 24 | isEmpty _ = False 25 | 26 | 27 | toList :: Reversed a -> [a] 28 | toList (Reversed list) = 29 | reverse list 30 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Links_inline_style.markdown: -------------------------------------------------------------------------------- 1 | Just a [URL](/url/). 2 | 3 | [URL and title](/url/ "title"). 4 | 5 | [URL and title](/url/ "title preceded by two spaces"). 6 | 7 | [URL and title](/url/ "title preceded by a tab"). 8 | 9 | [URL and title](/url/ "title has spaces afterward" ). 10 | 11 | [URL wrapped in angle brackets](). 12 | 13 | [URL w/ angle brackets + title]( "Here's the title"). 14 | 15 | [Empty](). 16 | 17 | [With parens in the URL](http://en.wikipedia.org/wiki/WIMP_(computing)) 18 | 19 | (With outer parens and [parens in url](/foo(bar))) 20 | 21 | 22 | [With parens in the URL](/foo(bar) "and a title") 23 | 24 | (With outer parens and [parens in url](/foo(bar) "and a title")) 25 | -------------------------------------------------------------------------------- /tests/test-files/CommonMark/Makefile: -------------------------------------------------------------------------------- 1 | SITE=_site 2 | SPECVERSION=$(shell perl -ne 'print $$1 if /^version: *([0-9.]+)/' spec.txt) 3 | 4 | .PHONY: all clean npm 5 | 6 | all: spec.html # spec.pdf spec.md 7 | 8 | spec.md: spec.txt tools/template.commonmark 9 | lua tools/make_spec.lua commonmark < $< > $@ 10 | 11 | spec.html: spec.txt tools/template.html 12 | lua tools/make_spec.lua html < $< > $@ 13 | 14 | spec.tex: spec.txt tools/template.latex 15 | lua tools/make_spec.lua latex < $< > $@ 16 | 17 | spec.pdf: spec.tex 18 | xelatex $< 19 | 20 | npm: 21 | # Do a sanity check first on versions 22 | grep -q '"version": *"$(SPECVERSION)' package.json && \ 23 | npm publish 24 | 25 | clean: 26 | -rm spec.tex spec.md spec.html 27 | -------------------------------------------------------------------------------- /tests/test-files/from-json/Elm-0.19/Patterns.elm: -------------------------------------------------------------------------------- 1 | module Patterns exposing (alias, closedList, data, emptyList, emptyRecord, literals, openList, record, tuple, unit, variables, wildcard) 2 | 3 | 4 | wildcard _ = 5 | () 6 | 7 | 8 | literals 1 2.0 "string" 'c' = 9 | () 10 | 11 | 12 | variables x = 13 | () 14 | 15 | 16 | data (Foo _ _) (Maybe.Just _ _) = 17 | () 18 | 19 | 20 | unit () = 21 | () 22 | 23 | 24 | tuple ( _, _ ) = 25 | () 26 | 27 | 28 | emptyList [] = 29 | () 30 | 31 | 32 | closedList [ _, _ ] = 33 | () 34 | 35 | 36 | openList (_ :: _ :: _) = 37 | () 38 | 39 | 40 | emptyRecord {} = 41 | () 42 | 43 | 44 | record { x, y } = 45 | () 46 | 47 | 48 | alias (_ as x) = 49 | () 50 | -------------------------------------------------------------------------------- /Style Guide/Sections.md: -------------------------------------------------------------------------------- 1 | # Sections and grouping 2 | 3 | Comments (`--`, `{- -}`) can be used to create sections within your code. 4 | 5 | 6 | ## Top-level sections 7 | 8 | ```elm 9 | x = 10 | () 11 | 12 | 13 | 14 | -- This comment introduces a new section 15 | 16 | 17 | a = 18 | () 19 | ``` 20 | 21 | 22 | ## Data structure sections 23 | 24 | ### List expressions 25 | 26 | ```elm 27 | x = 28 | [ 1 29 | , 2 30 | 31 | -- This comment introduces a section in the list 32 | , 3 33 | , 4 34 | ] 35 | ``` 36 | 37 | ### Record expressions 38 | 39 | ```elm 40 | x = 41 | { x = 1 42 | , y = 2 43 | 44 | -- This comment introduces a section in the record 45 | , a = 3 46 | , b = 4 47 | } 48 | ``` 49 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Images.html: -------------------------------------------------------------------------------- 1 |
Inline within a paragraph: alt text.
4 |.
.jpg)
One blockquote, two paragraphs:
2 |3 |6 |one
4 |two
5 |
Two blockquotes:
7 |8 |10 |one
9 |
11 |13 |two
12 |
Nested blockquote, two paragraphs:
14 |15 |20 |16 |19 |one
17 |two
18 |
Nested blockquote, two blockquotes:
21 |22 |29 |23 |25 |one
24 |26 |28 |two
27 |
Two nested blockquotes:
30 |31 |35 |32 |34 |one
33 |
36 |40 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Lists/TightAndLoose.html: -------------------------------------------------------------------------------- 1 |37 |39 |two
38 |
-
2 |
- tight 3 |
-
5 |
- tight 6 |
- list 7 |
-
9 |
loose
10 | list
11 |
-
13 |
- tight 14 |
- list 15 |
-
17 |
loose
18 | list
19 |
-
21 |
loose
22 |-
23 |
- sublist 24 |
25 |
-
27 |
- tight
28 |
-
29 |
- sublist 30 |
31 |
-
33 |
- tight
34 |
35 |
38 |blockquote 36 | and
37 |code 39 |
40 | - tight 41 |
-
43 |
loose
44 |-
45 |
with loose
46 | sublist
47 |
48 | loose
49 |
-
2 |
First Item
3 |-
4 |
one
5 |-
6 |
- two 7 |
8 | one
9 |-
10 |
- two 11 |
12 |
13 | Second Item
14 |-
15 |
- one
16 |
-
17 |
- two 18 |
19 |
20 | - one
16 |
-
22 |
- one
23 |
-
24 |
- two 25 |
26 |
-
28 |
Third Item
29 |-
30 |
- one
31 |
-
32 |
- two 33 |
34 |
35 | - one
31 |
-
37 |
- one
38 |
-
39 |
- two 40 |
41 |
-
43 |
Fourth Item
44 |-
45 |
- one
46 |
-
47 |
- two 48 |
49 |
50 | - one
46 |
-
52 |
- one
53 |
-
54 |
- two 55 |
56 |
This is a fenced code block:
2 |pairs :: [(Int,Char)]
3 | pairs = [(x,y) | x <- [0..10], y <- ['a'..'z']]
4 | Here is one with tildes:
6 |pairs :: [(Int,Char)]
7 | pairs = [(x,y) | x <- [0..10], y <- ['a'..'z']]
8 | More metadata:
10 |pairs :: [(Int,Char)]
11 | pairs = [(x,y) | x <- [0..10], y <- ['a'..'z']]
12 | More backticks:
14 |pairs :: [(Int,Char)]
15 | pairs = [(x,y) | x <- [0..10], y <- ['a'..'z']]
16 |
17 | backticks :: String
18 | backticks = "`````"
19 | Without an end:
21 |code with
22 | no end
23 |
24 | Just a URL.
2 | 3 | 4 | 5 | 6 |URL wrapped in angle brackets.
7 |URL w/ angle brackets + title.
8 | 9 | 10 |(With outer parens and parens in url)
11 | 12 |(With outer parens and parens in url)
13 | -------------------------------------------------------------------------------- /elm-format-lib/src/Parse/State.hs: -------------------------------------------------------------------------------- 1 | module Parse.State where 2 | 3 | 4 | data State = State 5 | { newline :: [Bool] 6 | } 7 | 8 | 9 | init :: State 10 | init = 11 | State 12 | { newline = [False] 13 | } 14 | 15 | 16 | setNewline :: State -> State 17 | setNewline state = 18 | case newline state of 19 | [] -> state 20 | (_:rest) -> state { newline = (True:rest) } 21 | 22 | 23 | pushNewlineContext :: State -> State 24 | pushNewlineContext state = 25 | state { newline = (False:(newline state)) } 26 | 27 | 28 | popNewlineContext :: State -> State 29 | popNewlineContext state = 30 | case newline state of 31 | [] -> state 32 | (_:[]) -> state 33 | (last:next:rest) -> state { newline = (last || next):rest } 34 | 35 | 36 | sawNewline :: State -> Bool 37 | sawNewline state = 38 | case newline state of 39 | [] -> False 40 | (b:_) -> b 41 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/Sorting.elm: -------------------------------------------------------------------------------- 1 | module Sorting exposing (x) 2 | 3 | import ConstructorTagsAreDeduplicated exposing(A(X, X, X)) 4 | import ConstructorTagsAreMerged exposing (A(X, Y), B(A), B(..), A(C, D), C, C(..)) 5 | import ConstructorTagsAreSorted exposing (A(Y, Z, X, Yy, XYzZY)) 6 | import ExposedValuesAreDeduplicated exposing (x, (==/==), x, (==/==), Z, Z(..)) 7 | import ExposedValuesAreSorted exposing (x, (<>), a, (==/==), Y, Z(..)) 8 | import ImportsAreMerged exposing (A(X), b) 9 | import ImportsAreMerged exposing (A(Y), z) 10 | import ImportsAreMerged2 11 | import ImportsAreMerged2 exposing (..) 12 | import ImportsAreMerged3 exposing (x) 13 | import ImportsAreMerged3 exposing (..) 14 | import ImportsWithConflictingAs as Overridden 15 | import ImportsWithConflictingAs as Correct 16 | import ImportsWithConflictingAs2 17 | import ImportsWithConflictingAs2 as Correct 18 | 19 | 20 | x = 21 | () 22 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Emphasis/Pathological.html: -------------------------------------------------------------------------------- 1 |This input can take a long time to parse in some implementations.
2 |a 3 | a 4 | a 5 | a 6 | a 7 | a 8 | a 9 | a 10 | a 11 | a 12 | a 13 | a 14 | a 15 | a 16 | a 17 | a 18 | a 19 | a 20 | a 21 | a 22 | *a 23 | aaaaa
24 |*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**a*a**
25 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.19/AllSyntax/Module.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.Module exposing (CustomType(..), a, b, c) 2 | 3 | import Dict as D 4 | exposing 5 | ( Dict 6 | , empty 7 | , fromList 8 | ) 9 | import Json.Decode as Json 10 | import Maybe exposing (Maybe(..), map) 11 | import Result exposing (Result(..)) 12 | import Signal exposing (..) 13 | import String 14 | import Task 15 | exposing 16 | ( andMap 17 | , andThen 18 | , fail 19 | , fromMaybe 20 | , fromResult 21 | , map 22 | , map2 23 | , map3 24 | , map4 25 | , map5 26 | , mapError 27 | , onError 28 | , succeed 29 | , toMaybe 30 | , toResult 31 | ) 32 | 33 | 34 | type CustomType 35 | = TagA 36 | | TagB 37 | 38 | 39 | a = 40 | 1 41 | 42 | 43 | b = 44 | 2 45 | 46 | 47 | c = 48 | 3 49 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Inline_HTML_Simple.markdown: -------------------------------------------------------------------------------- 1 | Here's a simple block: 2 | 3 |
4 | foo
5 |
6 |
7 | This should be a code block, though:
8 |
9 |
10 | foo
11 |
12 |
13 | As should this:
14 |
15 | foo
16 |
17 | Now, nested:
18 |
19 |
20 |
26 |
27 | This should just be an HTML comment:
28 |
29 |
30 |
31 | Multiline:
32 |
33 |
37 |
38 | Code block:
39 |
40 |
41 |
42 | Just plain comment, with trailing spaces on the line:
43 |
44 |
45 |
46 | Code:
47 |
48 |
21 |
25 |
22 | foo
23 |
24 | 49 | 50 | Hr's: 51 | 52 |
53 | 54 |
55 | 56 |
57 | 58 |
59 | 60 |
61 | 62 |
63 | 64 |
65 | 66 |
67 | 68 |
69 | 70 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/Module.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.Module exposing (CustomType(TagA), a, b, c) 2 | 3 | import Dict as D 4 | exposing 5 | ( Dict 6 | , empty 7 | , fromList 8 | ) 9 | import Json.Decode as Json 10 | import Maybe exposing (Maybe(Just, Nothing), map) 11 | import Result exposing (Result(..)) 12 | import Signal exposing (..) 13 | import String 14 | import Task 15 | exposing 16 | ( andMap 17 | , andThen 18 | , fail 19 | , fromMaybe 20 | , fromResult 21 | , map 22 | , map2 23 | , map3 24 | , map4 25 | , map5 26 | , mapError 27 | , onError 28 | , succeed 29 | , toMaybe 30 | , toResult 31 | ) 32 | 33 | 34 | type CustomType 35 | = TagA 36 | | TagB 37 | 38 | 39 | a = 40 | 1 41 | 42 | 43 | b = 44 | 2 45 | 46 | 47 | c = 48 | 3 49 | -------------------------------------------------------------------------------- /Release Notes/0.6.1-alpha.md: -------------------------------------------------------------------------------- 1 | Okay, I lied in the [0.6.0-alpha announcement](https://github.com/avh4/elm-format/releases/tag/0.6.0-alpha) 😄 I decided to add one more big feature before preparing for the public beta. 2 | 3 | So I'm excited to announce elm-format-0.6.1-alpha! The one change is that elm-format now formats your documentation comments, *including any Elm code examples in your documentation*. 4 | 5 | Please try it out and let me know if you run into any problems. I had to make a few choices about what the normalized markdown format should be based on the doc comments of some existing packages, so if you have a lot of familiarity with markdown parsers and have opinions about this, or if you know of other projects that have defined a normalized markdown format, please create a discussion issue on github. 6 | 7 | ### Install 8 | 9 | [Download](https://github.com/avh4/elm-format#installation-) or run `npm install -g elm-format`. 10 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.16/github-avh4-elm-format-184.formatted.elm: -------------------------------------------------------------------------------- 1 | module Main (..) where 2 | 3 | 4 | update : CotwData.Msg -> Model -> ( Model, Cmd CotwData.Msg ) 5 | update msg model = 6 | case msg of 7 | SplashMsg NewGame -> 8 | ( { model | currentPage = CharCreationPage }, Cmd.none ) 9 | 10 | SplashMsg _ -> 11 | ( { model | currentPage = NotImplementedPage }, Cmd.none ) 12 | 13 | CharCreationMsg StartGame -> 14 | ( { model | currentPage = GamePage }, Cmd.none ) 15 | 16 | CharCreationMsg msg -> 17 | ( { model | character = CharCreation.update msg model.character }, Cmd.none ) 18 | 19 | GameMsg msg -> 20 | ( { model | game = Game.update msg model.game }, Cmd.none ) 21 | 22 | Keyboard (Just a) -> 23 | ( model, Cmd.none ) 24 | 25 | Keyboard (Maybe.Nothing) -> 26 | ( model, Cmd.none ) 27 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/LineComments/Types.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.LineComments.Types exposing (emptyRecord, record, recordExtension) 2 | 3 | import Dict 4 | 5 | 6 | emptyRecord : 7 | { --M 8 | } 9 | -> () 10 | emptyRecord _ = 11 | () 12 | 13 | 14 | record : 15 | { --N 16 | x : 17 | --P 18 | Int 19 | 20 | --Q 21 | , --R 22 | y 23 | --S 24 | : 25 | --T 26 | () 27 | 28 | --U 29 | } 30 | -> () 31 | record _ = 32 | () 33 | 34 | 35 | recordExtension : 36 | { --V 37 | a 38 | --W 39 | | --X 40 | x 41 | --Y 42 | : 43 | --Z 44 | Int 45 | 46 | --AA 47 | , --AB 48 | y 49 | --AC 50 | : 51 | --AD 52 | Int 53 | 54 | --AE 55 | } 56 | -> () 57 | recordExtension _ = 58 | () 59 | -------------------------------------------------------------------------------- /hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | - path: "./Shakefile/src" 4 | component: "build-elm-format:exe:build-elm-format" 5 | 6 | - path: "./avh4-lib/src/" 7 | component: "lib:avh4-lib" 8 | 9 | - path: "./avh4-lib/test/" 10 | component: "avh4-lib:test:al-tests" 11 | 12 | - path: "./elm-format-lib/src/" 13 | component: "lib:elm-format-lib" 14 | 15 | - path: "./elm-format-lib/test/" 16 | component: "elm-format-lib:test:efl-tests" 17 | 18 | - path: "./elm-format-markdown/" 19 | component: "lib:elm-format-markdown" 20 | 21 | - path: "./elm-format-test-lib/src/" 22 | component: "lib:elm-format-test-lib" 23 | 24 | - path: "./elm-format-test-lib/test/" 25 | component: "elm-format-test-lib:test:elm-format-test-lib-tests" 26 | 27 | - path: "./src/" 28 | component: "elm-format:exe:elm-format" 29 | 30 | - path: "./tests/" 31 | component: "elm-format:test:elm-format-tests" 32 | -------------------------------------------------------------------------------- /elm-format-lib/src/ElmFormat/Render/Text.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DataKinds #-} 2 | module ElmFormat.Render.Text where 3 | 4 | import Data.Coapplicative 5 | import Elm.Utils ((|>)) 6 | import ElmVersion (ElmVersion) 7 | import AST.Structure 8 | import AST.V0_16 9 | 10 | import AST.Module (Module) 11 | import qualified Box 12 | import qualified Data.Text as Text 13 | import qualified ElmFormat.Render.Box as Render 14 | 15 | 16 | render :: Coapplicative annf => ElmVersion -> Module [UppercaseIdentifier] (ASTNS annf [UppercaseIdentifier] 'TopLevelNK) -> Text.Text 17 | render elmVersion modu = 18 | renderBox $ Render.formatModule elmVersion True 2 modu 19 | 20 | 21 | renderBox :: Box.Box -> Text.Text 22 | renderBox box = 23 | box 24 | |> Box.render 25 | 26 | 27 | -- TODO: remove this and convert the Integration test to a test fixture 28 | renderLiteral :: ElmVersion -> LiteralValue -> Text.Text 29 | renderLiteral elmVersion literal = 30 | renderBox $ Render.formatLiteral elmVersion literal 31 | -------------------------------------------------------------------------------- /package/elm-tooling/generate.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -euo pipefail 3 | 4 | VERSION="$1" 5 | 6 | function print-version() { 7 | PLATFORM_ELM_TOOLING="$1" 8 | PLATFORM_ELM_FORMAT="$2" 9 | ZIP_TYPE="$3" 10 | EXT="${4-}" 11 | 12 | FILENAME="elm-format-$VERSION-$PLATFORM_ELM_FORMAT.$ZIP_TYPE" 13 | FILEPATH="../../publish/$VERSION/$FILENAME" 14 | 15 | echo " \"$PLATFORM_ELM_TOOLING\": {" 16 | echo " hash: \"$(sha256sum "$FILEPATH" | cut -d' ' -f1)\"," 17 | echo " url: \"https://github.com/avh4/elm-format/releases/download/$VERSION/$FILENAME\"," 18 | echo " fileSize: $(stat -c %s "$FILEPATH")," 19 | echo " fileName: \"elm-format$EXT\"," 20 | echo " type: \"$ZIP_TYPE\"," 21 | echo " }," 22 | } 23 | 24 | echo "\"$VERSION\": {" 25 | print-version darwin-arm64 mac-arm64 tgz 26 | print-version darwin-x64 mac-x64 tgz 27 | print-version linux-arm64 linux-aarch64 tgz 28 | print-version linux-x64 linux-x64 tgz 29 | print-version win32-x64 win-x64 zip .exe 30 | echo "}," 31 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/Expressions/BinaryOperators.elm: -------------------------------------------------------------------------------- 1 | module Main exposing (commentedInfixOperator, infixOperator, leftPipe, lineComments, multilineInfixOperators) 2 | 3 | 4 | infixOperator = 5 | 1 + 2 * 3 / 4 <> 5 |> (+) 0 6 | 7 | 8 | multilineInfixOperators = 9 | 1 10 | + 2 11 | * 3 12 | / 4 13 | <> 5 14 | |> (+) 0 15 | 16 | 17 | commentedInfixOperator = 18 | 1 {- plus -} + 2 19 | 20 | 21 | lineComments = 22 | () 23 | |> identity 24 | |> identity 25 | --X 26 | |> identity 27 | 28 | 29 | leftPipe a = 30 | a <| 31 | a <| 32 | a <| 33 | () 34 | 35 | 36 | {-| elm-format will auto-correct `=>` to `->` when used in types and lambda introductions, 37 | but for Elm <= 0.18, it is valid as an expression and should be untouched in that usage. 38 | -} 39 | fatArrowOperator = 40 | let 41 | (=>) a b = 42 | () 43 | in 44 | 1 => 2 => 3 45 | -------------------------------------------------------------------------------- /avh4-lib/test/Data/List/ExtraTest.hs: -------------------------------------------------------------------------------- 1 | module Data.List.ExtraTest where 2 | 3 | import Test.Tasty 4 | import Test.Tasty.HUnit 5 | 6 | import Data.List.Extra 7 | 8 | 9 | tests :: TestTree 10 | tests = 11 | testGroup "Util.List" 12 | [ testGroup "pairs" 13 | [ testCase "" $ assertEqual "" [(1,2), (2,3)] $ pairs [1, 2, 3] 14 | , testCase "empty" $ assertEqual "" [] $ pairs ([] :: [Int]) 15 | , testCase "single" $ assertEqual "" [] $ pairs [1] 16 | ] 17 | , testGroup "intersperseMap" 18 | [ testCase "" $ assertEqual "" [ 21, 20050, 51, 50070, 71 ] $ intersperseMap (\a b -> [1000*a+b]) (\a -> a + 1) [ 20, 50, 70] 19 | , testCase "empty" $ assertEqual "" [] $ intersperseMap (\a b -> []) id ([] :: [Int]) 20 | ] 21 | , testGroup "shift" 22 | [ testCase "" $ assertEqual "" ([("a",1), ("b",2)], "c") $ shift "a" [(1,"b"), (2,"c")] 23 | , testCase "" $ assertEqual "empty" ([],"x") $ shift "x" ([] :: [(Int,String)]) 24 | ] 25 | ] 26 | -------------------------------------------------------------------------------- /tests/test-files/from-json/Elm-0.19/ModuleImports.json: -------------------------------------------------------------------------------- 1 | { 2 | "moduleName": "ModuleImports", 3 | "imports": { 4 | "SingleWordNoAlias": {}, 5 | "Multi.Word.NoAlias": {}, 6 | "SingleWordAlias": { "as": "S" }, 7 | "Multi.Word.Alias": { "as": "WordAlias" }, 8 | "Exposing.Everything": { "exposing": "Everything" }, 9 | "Exposing.Values": { 10 | "exposing": { 11 | "values": ["a", "b"] 12 | } 13 | }, 14 | "Exposing.Types": { 15 | "exposing": { 16 | "types": { 17 | "ExposeAllTags": "AllTags", 18 | "ExposeNoTags": "NoTags" 19 | } 20 | } 21 | } 22 | }, 23 | "body": [ 24 | { 25 | "tag": "Definition", 26 | "name": "f", 27 | "parameters": [], 28 | "expression": { 29 | "tag": "UnitLiteral" 30 | } 31 | } 32 | ] 33 | } 34 | -------------------------------------------------------------------------------- /elm-format-markdown/tests/Original/Inline_HTML_Simple.html: -------------------------------------------------------------------------------- 1 |
Here's a simple block:
2 |
3 | foo
4 |
5 | This should be a code block, though:
6 |<div>
7 | foo
8 | </div>
9 | As should this:
11 |<div>foo</div>
12 | Now, nested:
14 |
15 |
21 |
16 |
20 |
17 | foo
18 |
19 | This should just be an HTML comment:
22 | 23 |Multiline:
24 | 28 |Code block:
29 |<!-- Comment -->
30 | Just plain comment, with trailing spaces on the line:
32 | 33 |Code:
34 |<hr />
35 | Hr's:
37 |38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 | -------------------------------------------------------------------------------- /elm-format-lib/src/ElmFormat/KnownContents.hs: -------------------------------------------------------------------------------- 1 | module ElmFormat.KnownContents 2 | ( KnownContents 3 | , fromFunction 4 | , isKnown, get 5 | ) 6 | where 7 | 8 | import AST.V0_16 9 | 10 | newtype KnownContents = 11 | KnownContents ([UppercaseIdentifier] -> Maybe [LocalName]) -- return Nothing if the contents are unknown 12 | 13 | instance Semigroup KnownContents where 14 | (KnownContents a) <> (KnownContents b) = KnownContents (\ns -> a ns <> b ns) 15 | 16 | instance Monoid KnownContents where 17 | mempty = fromFunction (const Nothing) 18 | 19 | 20 | fromFunction :: ([UppercaseIdentifier] -> Maybe [LocalName]) -> KnownContents 21 | {-# INLINE fromFunction #-} 22 | fromFunction = KnownContents 23 | 24 | 25 | isKnown :: KnownContents -> [UppercaseIdentifier] -> Bool 26 | isKnown (KnownContents lookup) = 27 | maybe False (const True) . lookup 28 | 29 | 30 | get :: [UppercaseIdentifier] -> KnownContents -> Maybe [LocalName] 31 | {-# INLINE get #-} 32 | get ns (KnownContents lookup) = 33 | lookup ns 34 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/ModuleWithDocs.elm: -------------------------------------------------------------------------------- 1 | module AllSyntax.ModuleWithDocs exposing 2 | ( CustomType(TagA), a 3 | , b, c 4 | ) 5 | 6 | {-| 7 | 8 | @docs CustomType, a 9 | 10 | -} 11 | 12 | import Dict as D 13 | exposing 14 | ( Dict 15 | , empty 16 | , fromList 17 | ) 18 | import Json.Decode as Json 19 | import Maybe exposing (Maybe(Just, Nothing), map) 20 | import Result exposing (Result(..)) 21 | import Signal exposing (..) 22 | import String 23 | import Task 24 | exposing 25 | ( andMap 26 | , andThen 27 | , fail 28 | , fromMaybe 29 | , fromResult 30 | , map 31 | , map2 32 | , map3 33 | , map4 34 | , map5 35 | , mapError 36 | , onError 37 | , succeed 38 | , toMaybe 39 | , toResult 40 | ) 41 | 42 | 43 | type CustomType 44 | = TagA 45 | | TagB 46 | 47 | 48 | a = 49 | 1 50 | 51 | 52 | b = 53 | 2 54 | 55 | 56 | c = 57 | 3 58 | -------------------------------------------------------------------------------- /tests/test-files/good/Elm-0.18/AllSyntax/BlockComments/Module.elm: -------------------------------------------------------------------------------- 1 | {- AD -} 2 | 3 | 4 | module {- A -} AllSyntax.BlockComments.Module {- B -} {- I -} exposing ({- C -} a {- D -}, {- E -} b {- F -}, {- G -} c {- H -}) 5 | 6 | {- J -} {- K -} 7 | 8 | import {- P -} Json.Decode {- Q -} as {- R -} Json 9 | import {- M -} Maybe {- N -} exposing {- O -} ({- S -} Maybe {- W -} ({- X -} Just {- Y -}, {- Z -} Nothing {- AA -}) {- T -}, {- U -} map {- V -}) 10 | import Signal exposing ({- AB -} .. {- AC -}) 11 | import {- L -} String 12 | import Task 13 | exposing 14 | ( andMap 15 | , andThen 16 | , fail {- AE -} 17 | , fromMaybe 18 | , fromResult 19 | , map 20 | , map2 21 | , map3 22 | , map4 23 | , map5 24 | , mapError 25 | , onError 26 | , succeed {- AD -} 27 | , toMaybe 28 | , toResult 29 | ) 30 | 31 | 32 | 33 | {- AF -} 34 | 35 | 36 | a = 37 | 1 38 | 39 | 40 | b = 41 | 2 42 | 43 | 44 | c = 45 | 3 46 | -------------------------------------------------------------------------------- /.github/workflows/Build release.yml: -------------------------------------------------------------------------------- 1 | name: Build release 2 | 3 | on: 4 | push: 5 | tags: '*' 6 | branches: 'release/*' 7 | 8 | defaults: 9 | run: 10 | shell: bash 11 | 12 | jobs: 13 | build: 14 | strategy: 15 | fail-fast: false 16 | matrix: 17 | build: 18 | - name: windows 19 | runner: windows-latest 20 | archive-label: Windows 21 | - name: macOS-x86 22 | runner: macOS-latest 23 | archive-label: macOS-x86 24 | 25 | name: release-${{ matrix.build.name }} 26 | runs-on: ${{ matrix.build.runner }} 27 | 28 | steps: 29 | - name: Configure environment 30 | run: | 31 | git config --global core.autocrlf false 32 | - uses: actions/checkout@v3 33 | - uses: ./.github/actions/git-tags 34 | - uses: ./.github/actions/haskell 35 | - run: ./dev/build.sh -- dist-dependencies 36 | - run: ./dev/build.sh -- dist 37 | - uses: ./.github/actions/release-artifact 38 | with: 39 | minisign-key: ${{ secrets.MINISIGN_PRIVATE_KEY }} 40 | -------------------------------------------------------------------------------- /package/win/setup.md: -------------------------------------------------------------------------------- 1 | ## First time setup 2 | 3 | ```bash 4 | brew install caskroom/cask/brew-cask 5 | brew cask install vagrant 6 | brew cask install virtualbox 7 | #vagrant init opentable/win-2012r2-standard-amd64-nocm 8 | vagrant up 9 | vagrant plugin install vagrant-winrm 10 | vagrant winrm -c "dir" 11 | ``` 12 | 13 | ## Start Windows VM 14 | 15 | - `(cd package/win && vagrant up)` 16 | - Open VirtualBox and show the runnning Windows VM 17 | - Start Git Bash (Right click on Windows Desktop -> "Git Bash Here") 18 | 19 | 20 | ## Build Windows binary 21 | 22 | From the host computer: 23 | 24 | - `cd package/win/elm-format` 25 | - `git fetch` 26 | 27 | From the Windows VM: 28 | 29 | - `cd /c/vagrant/elm-format` 30 | - `git checkout
Foo bar.
2 |Foo bar.
3 |Foo bar.
4 |With embedded [brackets].
5 |Indented once.
6 |Indented twice.
7 |Indented thrice.
8 |Indented [four][] times.
9 |[four]: /url
10 | 12 |
this should work
13 |So should this.
14 |And this.
15 |And this.
16 |And this.
17 |But not [that] [].
18 |Nor [that][].
19 |Nor [that].
20 |[Something in brackets like this should work]
21 |[Same with this.]
22 |In this case, this points to something else.
23 |Backslashing should suppress [this] and [this].
24 |25 |
Here's one where the link 26 | breaks across lines.
27 |Here's another where the link 28 | breaks across lines, but with a line-ending space.
29 | -------------------------------------------------------------------------------- /tests/test-files/transform/Elm-0.18/UnnecessaryParens.formatted.elm: -------------------------------------------------------------------------------- 1 | module UnnecessaryParens exposing (unnecessaryParens) 2 | 3 | 4 | unnecessaryParens = 5 | ( "a" ++ f x y ++ "b" 6 | , f x y 7 | , x 8 | , [ 1, 2 ] 9 | , 1 + (x + 1) 10 | , { blah = foo << bar 11 | , stuff = 12 | if conditional then 13 | something 14 | 15 | else 16 | somethingElse 17 | , thing = doSomething (func arg) 18 | } 19 | , if x then 20 | something 21 | 22 | else 23 | somethingElse 24 | , case foo of 25 | () -> 26 | () 27 | , r.f1.f2.f3.f4 28 | , test "test" <| 29 | \() -> 30 | 1 |> Expect.equal 1 31 | ) 32 | 33 | 34 | allowedParens = 35 | ( (x + 1) + (y - 1) 36 | , () 37 | ) 38 | 39 | 40 | requiredParens = 41 | ( (maybeF |> Maybe.withDefault identity) 1 42 | , Ok <| ([ 1, 2, 3 ] |> List.tail) 43 | , () 44 | ) 45 | 46 | 47 | requiredParensForTrailingCommentsInBinopsContext = 48 | () 49 | |> (\() -> 50 | () 51 | -- comment stay here 52 | ) 53 | 54 | 55 | requiredParensForTrailingCommentsInDefBodyContext = 56 | (8 57 | -- comment stay here 58 | ) 59 | --------------------------------------------------------------------------------