elm.json

@@ -5,25 +5,6 @@
     "license": "EUPL-1.1",
     "version": "2.1.0",
     "exposed-modules": [
-        "Internal.Config.Default",
-        "Internal.Config.Leaks",
-        "Internal.Config.Log",
-        "Internal.Config.Phantom",
-        "Internal.Config.Text",
-        "Internal.Tools.DecodeExtra",
-        "Internal.Tools.EncodeExtra",
-        "Internal.Tools.Hashdict",
-        "Internal.Tools.Iddict",
-        "Internal.Tools.Json",
-        "Internal.Tools.Mashdict",
-        "Internal.Tools.Timestamp",
-        "Internal.Tools.VersionControl",
-        "Internal.Values.Context",
-        "Internal.Values.Envelope",
-        "Internal.Values.Event",
-        "Internal.Values.Settings",
-        "Internal.Values.StateManager",
-        "Internal.Values.Vault",
         "Matrix",
         "Matrix.Event",
         "Matrix.Settings"

src/Internal/Config/Leaks.elm

@@ -48,8 +48,6 @@ accessToken =
     "elm-sdk-placeholder-access-token-leaks"
 
 
-{-| Complete set of all leaking values. Commonly using for testing purposes.
--}
 allLeaks : Set String
 allLeaks =
     Set.union

src/Internal/Config/Log.elm

@@ -1,4 +1,4 @@
-module Internal.Config.Log exposing (Log, log)
+module Internal.Config.Log exposing (caughtError, debug, error, info, securityWarn, warn)
 
 {-|
 
@@ -8,45 +8,12 @@ module Internal.Config.Log exposing (Log, log)
 The logs module exposes various log types that can be used to indicate logs.
 This helps users filter for the logs that they care about.
 
-@docs Log, log
-
 The logs are encoded as strings as to allow the addition of new log types
 without triggering a major update.
 
--}
-
--- @docs caughtError, debug, error, info, securityWarn, warn
-
-
-{-| Common pattern for a log message. The log message consists of a log channel
-like `debug`, `warn`, `error`, etc. and the content of the message.
-
-These logs are completely optional: they can be ignored, they can be sent to the
-console, or a dialog may be created that presents the log messages.
+@docs caughtError, debug, error, info, securityWarn, warn
 
 -}
-type alias Log =
-    { channel : String, content : String }
-
-
-{-| Create a log message of various log types.
--}
-log :
-    { caughtError : String -> Log
-    , debug : String -> Log
-    , error : String -> Log
-    , info : String -> Log
-    , securityWarn : String -> Log
-    , warn : String -> Log
-    }
-log =
-    { caughtError = Log caughtError
-    , debug = Log debug
-    , error = Log error
-    , info = Log info
-    , securityWarn = Log securityWarn
-    , warn = Log warn
-    }
 
 
 {-| A caught error is an error that has been caught elsewhere in the code, hence

src/Internal/Config/Text.elm

@@ -81,9 +81,6 @@ accessTokenInvalid =
     "Matrix API rejected access token as invalid"
 
 
-{-| Logs when the JSON decoder detects that an imported dictionary contained
-duplicate keys.
--}
 decodedDictSize : Int -> Int -> String
 decodedDictSize from to =
     String.concat

tests/Test/Tools/Json.elm

@@ -1,249 +0,0 @@
-module Test.Tools.Json exposing (..)
-
-import Expect
-import Fuzz exposing (Fuzzer)
-import Internal.Tools.Json as Json
-import Json.Decode as D
-import Json.Encode as E
-import Test exposing (..)
-
-
-type alias Human2 =
-    { name : String, age : Maybe Int }
-
-
-type alias Human3 =
-    { name : String, age : Maybe Int, hobbies : List String }
-
-
-type alias Human4 =
-    { name : String
-    , age : Maybe Int
-    , hobbies : List String
-    , weight : Maybe Float
-    }
-
-
-type alias Human5 =
-    { name : String
-    , age : Maybe Int
-    , hobbies : List String
-    , weight : Maybe Float
-    , height : Float
-    }
-
-
-ageField : Json.Field (Maybe Int) { a | age : Maybe Int }
-ageField =
-    Json.field.optional.value
-        { fieldName = "age"
-        , toField = .age
-        , description = []
-        , coder = Json.int
-        }
-
-
-ageFuzzer : Fuzzer (Maybe Int)
-ageFuzzer =
-    Fuzz.maybe Fuzz.int
-
-
-heightField : Json.Field Float { a | height : Float }
-heightField =
-    Json.field.required
-        { fieldName = "height"
-        , toField = .height
-        , description = []
-        , coder = Json.float
-        }
-
-
-heightFuzzer : Fuzzer Float
-heightFuzzer =
-    Fuzz.niceFloat
-
-
-hobbiesField : Json.Field (List String) { a | hobbies : List String }
-hobbiesField =
-    Json.field.optional.withDefault
-        { fieldName = "hobbies"
-        , toField = .hobbies
-        , description = []
-        , coder = Json.list Json.string
-        , default = ( [], [] )
-        , defaultToString = always "[]"
-        }
-
-
-hobbiesFuzzer : Fuzzer (List String)
-hobbiesFuzzer =
-    Fuzz.list Fuzz.string
-
-
-nameField : Json.Field String { a | name : String }
-nameField =
-    Json.field.required
-        { fieldName = "name"
-        , toField = .name
-        , description = []
-        , coder = Json.string
-        }
-
-
-nameFuzzer : Fuzzer String
-nameFuzzer =
-    Fuzz.string
-
-
-weightField : Json.Field (Maybe Float) { a | weight : Maybe Float }
-weightField =
-    Json.field.optional.value
-        { fieldName = "weight"
-        , toField = .weight
-        , description = []
-        , coder = Json.float
-        }
-
-
-weightFuzzer : Fuzzer (Maybe Float)
-weightFuzzer =
-    -- TODO: Maybe make Float not so nice?
-    Fuzz.maybe Fuzz.niceFloat
-
-
-human2Coder : Json.Coder Human2
-human2Coder =
-    Json.object2
-        { name = "Human2"
-        , description = []
-        , init = Human2
-        }
-        nameField
-        ageField
-
-
-human2Fuzzer : Fuzzer Human2
-human2Fuzzer =
-    Fuzz.map2 Human2
-        nameFuzzer
-        ageFuzzer
-
-
-human3Coder : Json.Coder Human3
-human3Coder =
-    Json.object3
-        { name = "Human3"
-        , description = []
-        , init = Human3
-        }
-        nameField
-        ageField
-        hobbiesField
-
-
-human3Fuzzer : Fuzzer Human3
-human3Fuzzer =
-    Fuzz.map3 Human3
-        nameFuzzer
-        ageFuzzer
-        hobbiesFuzzer
-
-
-human4Coder : Json.Coder Human4
-human4Coder =
-    Json.object4
-        { name = "Human4"
-        , description = []
-        , init = Human4
-        }
-        nameField
-        ageField
-        hobbiesField
-        weightField
-
-
-human4Fuzzer : Fuzzer Human4
-human4Fuzzer =
-    Fuzz.map4 Human4
-        nameFuzzer
-        ageFuzzer
-        hobbiesFuzzer
-        weightFuzzer
-
-
-human5Coder : Json.Coder Human5
-human5Coder =
-    Json.object5
-        { name = "Human5"
-        , description = []
-        , init = Human5
-        }
-        nameField
-        ageField
-        hobbiesField
-        weightField
-        heightField
-
-
-human5Fuzzer : Fuzzer Human5
-human5Fuzzer =
-    Fuzz.map5 Human5
-        nameFuzzer
-        ageFuzzer
-        hobbiesFuzzer
-        weightFuzzer
-        heightFuzzer
-
-
-suite : Test
-suite =
-    describe "JSON module"
-        [ describe "Human2"
-            [ fuzz human2Fuzzer
-                "Recoding succeeds"
-                (\human ->
-                    human
-                        |> Json.encode human2Coder
-                        |> E.encode 0
-                        |> D.decodeString (Json.decode human2Coder)
-                        |> Result.map Tuple.first
-                        |> Expect.equal (Ok human)
-                )
-            ]
-        , describe "Human3"
-            [ fuzz human3Fuzzer
-                "Recoding succeeds"
-                (\human ->
-                    human
-                        |> Json.encode human3Coder
-                        |> E.encode 0
-                        |> D.decodeString (Json.decode human3Coder)
-                        |> Result.map Tuple.first
-                        |> Expect.equal (Ok human)
-                )
-            ]
-        , describe "Human4"
-            [ fuzz human4Fuzzer
-                "Recoding succeeds"
-                (\human ->
-                    human
-                        |> Json.encode human4Coder
-                        |> E.encode 0
-                        |> D.decodeString (Json.decode human4Coder)
-                        |> Result.map Tuple.first
-                        |> Expect.equal (Ok human)
-                )
-            ]
-        , describe "Human5"
-            [ fuzz human5Fuzzer
-                "Recoding succeeds"
-                (\human ->
-                    human
-                        |> Json.encode human5Coder
-                        |> E.encode 0
-                        |> D.decodeString (Json.decode human5Coder)
-                        |> Result.map Tuple.first
-                        |> Expect.equal (Ok human)
-                )
-            ]
-        ]