Fantomas

Author: dbrattli

.fantomasignore

@@ -0,0 +1,5 @@
+Build.fs
+Helpers.fs
+
+# Ignore script files
+*.fsx

src/Ast.fs

@@ -111,15 +111,15 @@ type IExports =
     /// Parse the source into an AST node
     abstract parse : string -> AST
     abstract parse : string * filename: string -> AST
-    abstract parse : string * filename: string * mode: Mode-> AST
+    abstract parse : string * filename: string * mode: Mode -> AST
     abstract unparse : astObj: AST -> string
     abstract walk : node: AST -> AST array
     /// Return a formatted dump of the tree in node.
-    abstract dump : node : AST -> string
+    abstract dump : node: AST -> string
     /// Return a formatted dump of the tree in node.
-    abstract dump : node : AST * annotate_fields : bool -> string
+    abstract dump : node: AST * annotate_fields: bool -> string
     /// Return a formatted dump of the tree in node.
-    abstract dump : node : AST * annotate_fields : bool * include_attributes: bool -> string
+    abstract dump : node: AST * annotate_fields: bool * include_attributes: bool -> string
 
 [<ImportDefault("ast")>]
 let ast: IExports = nativeOnly

src/Json.fs

@@ -1,12 +1,12 @@
-module Fable.Python.Json
-
-open Fable.Core
-
-// fsharplint:disable MemberNames,InterfaceNames
-
-type IExports =
-    abstract dumps : obj: obj -> string
-    abstract loads : string -> obj
-
-[<ImportDefault("json")>]
-let json: IExports = nativeOnly
+module Fable.Python.Json
+
+open Fable.Core
+
+// fsharplint:disable MemberNames,InterfaceNames
+
+type IExports =
+    abstract dumps : obj: obj -> string
+    abstract loads : string -> obj
+
+[<ImportDefault("json")>]
+let json: IExports = nativeOnly

test/Main.fs

@@ -1,6 +1,9 @@
 #if FABLE_COMPILER
 module Program
+
 ()
 #else
-module Program = let [<EntryPoint>] main _ = 0
-#endif
+module Program =
+    [<EntryPoint>]
+    let main _ = 0
+#endif

test/TestAst.fs

@@ -6,17 +6,15 @@ open Fable.Python.Ast
 [<Fact>]
 let ``test ast parse empty module works`` () =
     let result = ast.parse ""
-    result.GetType () |> equal typeof<AST>
+    result.GetType() |> equal typeof<AST>
 
 [<Fact>]
 let ``test ast parse assign works`` () =
     let result = ast.parse "a = 10" :?> Module
 
     // Result is a list of statements
-    result.body.[0].GetType () |> equal typeof<stmt>
+    result.body.[0].GetType() |> equal typeof<stmt>
 
     // The statement is an assign statement
     let assign = (result.body.[0] :?> Assign)
-    assign.GetType () |> equal typeof<Assign>
-
-
+    assign.GetType() |> equal typeof<Assign>

test/TestJson.fs

@@ -15,13 +15,13 @@ let ``test works`` () =
 
 [<Fact>]
 let ``test json dumps works`` () =
-    let object = {| A=10; B=20 |}
-    let result =  json.dumps object
+    let object = {| A = 10; B = 20 |}
+    let result = json.dumps object
     result |> equal """{"A": 10, "B": 20}"""
 
 [<Fact>]
 let ``test json loads works`` () =
     let input = """{"Foo": 10, "Bar": "test"}"""
-    let object = {| Foo=10; Bar="test" |}
-    let result : {| Foo: int; Bar: string |}= unbox (json.loads input)
+    let object = {| Foo = 10; Bar = "test" |}
+    let result: {| Foo: int; Bar: string |} = unbox (json.loads input)
     result |> equal object

test/Util.fs

@@ -9,24 +9,28 @@ module Testing =
 
     type Assert =
         [<Emit("assert $0 == $1")>]
-        static member AreEqual(actual: 'T, expected: 'T, ?msg: string): unit = nativeOnly
+        static member AreEqual(actual: 'T, expected: 'T, ?msg: string) : unit = nativeOnly
+
         [<Emit("assert not $0 == $1")>]
-        static member NotEqual(actual: 'T, expected: 'T, ?msg: string): unit = nativeOnly
+        static member NotEqual(actual: 'T, expected: 'T, ?msg: string) : unit = nativeOnly
 
-    let equal expected actual: unit = Assert.AreEqual(actual, expected)
-    let notEqual expected actual: unit = Assert.NotEqual(actual, expected)
+    let equal expected actual : unit = Assert.AreEqual(actual, expected)
+    let notEqual expected actual : unit = Assert.NotEqual(actual, expected)
 
-    type Fact() = inherit System.Attribute()
+    type Fact () =
+        inherit System.Attribute ()
 #else
     open Xunit
     type FactAttribute = Xunit.FactAttribute
 
-    let equal<'T> (expected: 'T) (actual: 'T): unit = Assert.Equal(expected, actual)
+    let equal<'T> (expected: 'T) (actual: 'T) : unit = Assert.Equal(expected, actual)
     let notEqual<'T> (expected: 'T) (actual: 'T) : unit = Assert.NotEqual(expected, actual)
 #endif
 
-    let rec sumFirstSeq (zs: seq<float>) (n: int): float =
-       match n with
-       | 0 -> 0.
-       | 1 -> Seq.head zs
-       | _ -> (Seq.head zs) + sumFirstSeq (Seq.skip 1 zs) (n-1)
+    let rec sumFirstSeq (zs: seq<float>) (n: int) : float =
+        match n with
+        | 0 -> 0.
+        | 1 -> Seq.head zs
+        | _ ->
+            (Seq.head zs)
+            + sumFirstSeq (Seq.skip 1 zs) (n - 1)