Merge pull request #4 from vsapronov/version-0.3

Version 0.3

Author: vsapronov

FSharp.Json.sln

@@ -38,6 +38,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "content", "content", "{8E6D
 		docsrc\content\supported_types.md = docsrc\content\supported_types.md
 		docsrc\content\transform.fsx = docsrc\content\transform.fsx
 		docsrc\content\unions.fsx = docsrc\content\unions.fsx
+		docsrc\content\untyped_data.fsx = docsrc\content\untyped_data.fsx
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{ED8079DD-2B06-4030-9F0F-DC548F98E1C4}"

RELEASE_NOTES.md

@@ -1,3 +1,10 @@
+#### 0.3
+* Fix for tuples containing option types
+* Support for char type
+* Support for enums based on byte and char types
+* Configurable enum mode
+* Configurable unformatted setting
+
 #### 0.2 
 * Single case union as wrapped type 
 

docsrc/content/enums.fsx

@@ -61,3 +61,38 @@ let json = Json.serialize data
 
 let deserialized = Json.deserialize<TheNumberEnum> json
 // data is { TheNumberEnum.value = NumberEnum.Three }
+
+(**
+Default enum behaviour
+----------------------
+
+Sometimes it's needed always serialize enum value as it's value.
+Annotating each member of any enum type would be cumbersome.
+[JsonConfig]() allows to override default enum behaviour.
+
+Check the example below:
+*)
+#r "FSharp.Json.dll"
+open FSharp.Json
+
+type NumberEnum =
+| One = 1
+| Two = 2
+| Three = 3
+
+// value will be represented as enum value name in JSON
+type TheNumberEnum = {
+    value: NumberEnum
+}
+
+let data = { TheNumberEnum.value = NumberEnum.Three }
+
+// create configuration instructing to serialize enum as enum value
+let config = JsonConfig.create(enumValue = EnumMode.Value)
+
+let json = Json.serializeEx config data
+// json is """{"value":3}"""
+// value was serialized as enum value which is 3
+
+let deserialized = Json.deserializeEx<TheNumberEnum> config json
+// data is { TheNumberEnum.value = NumberEnum.Three }

docsrc/content/index.md

@@ -58,6 +58,7 @@ Following pages are describing main features and aspects of FSharp.Json:
  * [Enums](enums.html)
  * [Unions](unions.html)
  * [Type Transform](transform.html)
+ * [Untyped Data](untyped_data.html)
 
 Each feature of FSharp.Json is thoroughly covered by [unit tests][unit_tests].
 

docsrc/content/supported_types.md

@@ -23,6 +23,10 @@ string
 ------
 Represented as `string` in JSON.
 
+char
+----
+Represented as `string` with single character in JSON.
+
 bool
 ----
 Represented as `bool` in JSON.
@@ -77,3 +81,7 @@ union
 -----
 Unions are represented as `object` with special structure in JSON.
 Read more on [Unions](unions.html) page.
+
+obj
+---
+Read [Untyped Data](untyped_data.html) page.

docsrc/content/untyped_data.fsx

@@ -0,0 +1,63 @@
+(*** hide ***)
+#I "../../bin/FSharp.Json"
+
+(**
+Untyped Data
+============
+
+Using obj type in F# code is bad code smell.
+Though FSharp.Json can serialize and deserialize structures without type information.
+For allowing obj type in serialization/deserialization allowUntyped flag should be set to `true` on [JsonConfig](reference/fsharp-json-jsonconfig.html).
+
+Serialization of obj
+--------------------
+
+When serializing obj FSharp.Json uses real run time type.
+
+Check this example:
+*)
+
+#r "FSharp.Json.dll"
+open FSharp.Json
+
+// Record type with obj member
+type ObjectRecord = {
+    value: obj
+}
+
+// Set string value to obj member
+let data = { ObjectRecord.value = "The string" }
+
+// Need to allow untyped data
+let config = JsonConfig.create(allowUntyped = true)
+
+let json = Json.serializeEx config data
+// json is """{"value": "The string"}"""
+// value was serialized as string because it was assigned to string
+
+(**
+Deserialization of obj
+----------------------
+
+When deserializing obj FSharp.Json assumes the type from JSON.
+
+See example below:
+*)
+
+#r "FSharp.Json.dll"
+open FSharp.Json
+
+// Record type with obj member
+type ObjectRecord = {
+    value: obj
+}
+
+// value is assigned to string
+let json = """{"value": "The string"}"""
+
+// Need to allow untyped data
+let config = JsonConfig.create(allowUntyped = true)
+
+let data = Json.deserializeEx<ObjectRecord> config json
+// data is { ObjectRecord.value = "The string" }
+// value was deserialized as string because it was string in JSON

docsrc/tools/templates/template.cshtml

@@ -47,6 +47,7 @@
             <li><a href="@Root/enums.html">Enums</a></li>
             <li><a href="@Root/unions.html">Unions</a></li>
             <li><a href="@Root/transform.html">Type Transform</a></li>
+            <li><a href="@Root/untyped_data.html">Untyped Data</a></li>
             <li class="divider"></li>
             <li><a href="@Root/reference/index.html">API Reference</a></li>
             <li class="divider"></li>

src/FSharp.Json/AssemblyInfo.fs

@@ -5,15 +5,15 @@ open System.Reflection
 [<assembly: AssemblyTitleAttribute("FSharp.Json")>]
 [<assembly: AssemblyProductAttribute("FSharp.Json")>]
 [<assembly: AssemblyDescriptionAttribute("F# JSON Reflection based serialization library")>]
-[<assembly: AssemblyVersionAttribute("0.2")>]
-[<assembly: AssemblyFileVersionAttribute("0.2")>]
+[<assembly: AssemblyVersionAttribute("0.3")>]
+[<assembly: AssemblyFileVersionAttribute("0.3")>]
 [<assembly: AssemblyConfigurationAttribute("Release")>]
 do ()
 
 module internal AssemblyVersionInformation =
     let [<Literal>] AssemblyTitle = "FSharp.Json"
     let [<Literal>] AssemblyProduct = "FSharp.Json"
     let [<Literal>] AssemblyDescription = "F# JSON Reflection based serialization library"
-    let [<Literal>] AssemblyVersion = "0.2"
-    let [<Literal>] AssemblyFileVersion = "0.2"
+    let [<Literal>] AssemblyVersion = "0.3"
+    let [<Literal>] AssemblyFileVersion = "0.3"
     let [<Literal>] AssemblyConfiguration = "Release"

src/FSharp.Json/Core.fs

@@ -62,28 +62,51 @@ module internal Core =
             let valueType = value.GetType()
             (valueType, value)
 
+    let getEnumMode (config: JsonConfig) (jsonField: JsonField) =
+        match jsonField.EnumValue with
+        | EnumMode.Default ->
+            match config.enumValue with
+            | EnumMode.Default -> EnumMode.Name
+            | m -> m
+        | m -> m 
+
     let failSerialization (message: string) =
         raise (new JsonSerializationError(message))
 
     let rec serialize (config: JsonConfig) (t: Type) (value: obj): JsonValue =
         let serializeEnum (t: Type) (jsonField: JsonField) (value: obj): JsonValue =
-            match jsonField.EnumValue with
+            let baseT = Enum.GetUnderlyingType t
+            let enumMode = getEnumMode config jsonField
+            match enumMode with
             | EnumMode.Value ->
-                let index = decimal (value :?> int)
-                JsonValue.Number index
+                match baseT with
+                | t when t = typeof<int> ->
+                    let enumValue = decimal (value :?> int)
+                    JsonValue.Number enumValue
+                | t when t = typeof<byte> ->
+                    let enumValue = decimal (value :?> byte)
+                    JsonValue.Number enumValue
+                | t when t = typeof<char> ->
+                    let enumValue = sprintf "%c" (value :?> char)
+                    JsonValue.String enumValue
             | EnumMode.Name ->
                 let strvalue = Enum.GetName(t, value)
                 JsonValue.String strvalue
             | mode -> failSerialization <| sprintf "Failed to serialize enum %s, unsupported enum mode: %A" t.Name mode
 
+        let getUntypedType (t: Type) (value: obj): Type =
+            if t = typeof<obj> then
+                if config.allowUntyped then
+                    value.GetType()
+                else
+                    failSerialization <| "Failed to serialize untyped data, allowUntyped set to false"
+            else t
+
         let serializeNonOption (t: Type) (jsonField: JsonField) (value: obj): JsonValue =
             match jsonField.AsJson with
             | false ->
                 let t, value = transformToTargetType t value jsonField.Transform
-                let t =
-                    if t = typeof<obj> then
-                        value.GetType()
-                    else t
+                let t = getUntypedType t value
                 match t with
                 | t when t = typeof<int> ->
                     JsonValue.Number (decimal (value :?> int))
@@ -97,6 +120,8 @@ module internal Core =
                     JsonValue.Boolean (value :?> bool)
                 | t when t = typeof<string> ->
                     JsonValue.String (value :?> string)
+                | t when t = typeof<char> ->
+                    JsonValue.String (string(value :?> char))
                 | t when t = typeof<DateTime> ->
                     JsonValue.String ((value :?> DateTime).ToString(jsonField.DateTimeFormat))
                 | t when t = typeof<DateTimeOffset> ->
@@ -127,6 +152,15 @@ module internal Core =
                     | Omit -> None
             | _ -> Some (serializeNonOption t jsonField value)
 
+        let serializeUnwrapOptionWithNull (t: Type) (jsonField: JsonField) (value: obj): JsonValue =
+            match t with
+            |  t when isOption t ->
+                let unwrapedValue = unwrapOption t value
+                match unwrapedValue with
+                | Some value -> serializeNonOption (getOptionType t) jsonField value
+                | None -> JsonValue.Null
+            | _ -> serializeNonOption t jsonField value
+
         let serializeProperty (therec: obj) (prop: PropertyInfo): (string*JsonValue) option =
             let jsonField = getJsonFieldProperty prop
             let propValue = prop.GetValue(therec, Array.empty)
@@ -139,7 +173,17 @@ module internal Core =
         let serializeEnumerable (values: IEnumerable): JsonValue =
             let items =
                 values.Cast<Object>()
-                |> Seq.map (fun value -> serializeUnwrapOption (value.GetType()) JsonField.Default value)
+                |> Seq.map (fun value -> 
+                    serializeUnwrapOption (value.GetType()) JsonField.Default value)
+                |> Seq.map (someOrDefault JsonValue.Null)
+            items |> Array.ofSeq |> JsonValue.Array
+
+        let serializeTupleItems (types: Type seq) (values: IEnumerable): JsonValue =
+            let items =
+                values.Cast<Object>()
+                |> Seq.zip types
+                |> Seq.map (fun (t, value) -> 
+                    serializeUnwrapOption t JsonField.Default value)
                 |> Seq.map (someOrDefault JsonValue.Null)
             items |> Array.ofSeq |> JsonValue.Array
 
@@ -162,13 +206,15 @@ module internal Core =
         let serializeUnion (t: Type) (theunion: obj): JsonValue =
             let caseInfo, values = FSharpValue.GetUnionFields(theunion, t)
             let jsonField = getJsonFieldUnionCase caseInfo
+            let types = caseInfo.GetFields() |> Array.map (fun p -> p.PropertyType)
             let jvalue =
                 match values.Length with
                 | 1 ->
                     let caseValue = values.[0]
-                    serializeNonOption (caseValue.GetType()) jsonField caseValue
+                    let caseType = types.[0]
+                    serializeUnwrapOptionWithNull caseType jsonField caseValue
                 | _ ->
-                    serializeEnumerable values
+                    serializeTupleItems types values
             let unionCases = getUnionCases caseInfo.DeclaringType
             match unionCases.Length with
             | 1 -> jvalue
@@ -189,7 +235,7 @@ module internal Core =
         | t when isMap t -> serializeKvpEnumerable (value :?> IEnumerable)
         | t when isArray t -> serializeEnumerable (value :?> IEnumerable)
         | t when isList t -> serializeEnumerable (value :?> IEnumerable)
-        | t when isTuple t -> serializeEnumerable (FSharpValue.GetTupleFields value)
+        | t when isTuple t -> serializeTupleItems (getTupleElements t) (FSharpValue.GetTupleFields value)
         | t when isUnion t -> serializeUnion t value
         | t ->
             let msg = sprintf "Failed to serialize, must be one of following types: record, map, array, list, tuple, union. Type is: %s." t.Name
@@ -221,15 +267,34 @@ module internal Core =
 
     let rec deserialize (config: JsonConfig) (path: JsonPath) (t: Type) (jvalue: JsonValue): obj =
         let deserializeEnum (path: JsonPath) (t: Type) (jsonField: JsonField) (jvalue: JsonValue): obj =
-            match jsonField.EnumValue with
+            let baseT = Enum.GetUnderlyingType t
+            let enumMode = getEnumMode config jsonField
+            match enumMode with
             | EnumMode.Value ->
-                let index = JsonValueHelpers.getInt path jvalue
-                Enum.ToObject(t, index)
+                match baseT with
+                | baseT when baseT = typeof<int> ->
+                    let enumValue = JsonValueHelpers.getInt path jvalue
+                    Enum.ToObject(t, enumValue)
+                | baseT when baseT = typeof<byte> ->
+                    let enumValue = JsonValueHelpers.getByte path jvalue
+                    Enum.ToObject(t, enumValue)
+                | baseT when baseT = typeof<char> ->
+                    let enumValue = JsonValueHelpers.getChar path jvalue
+                    Enum.ToObject(t, enumValue)
             | EnumMode.Name ->
                 let valueStr = JsonValueHelpers.getString path jvalue
                 Enum.Parse(t, valueStr)
             | mode -> failDeserialization path <| sprintf "Failed to deserialize enum %s, unsupported enum mode: %A" t.Name mode
 
+        let getUntypedType (path: JsonPath) (t: Type) (jvalue: JsonValue): Type =
+            match t with
+            | t when t = typeof<obj> ->
+                if config.allowUntyped then
+                    getJsonValueType jvalue
+                else
+                    failDeserialization path <| sprintf "Failed to deserialize object, allowUntyped set to false"
+            | t -> t 
+
         let deserializeNonOption (path: JsonPath) (t: Type) (jsonField: JsonField) (jvalue: JsonValue): obj =
             match jsonField.AsJson with
             | true ->
@@ -238,10 +303,7 @@ module internal Core =
                 | _ -> jvalue.ToString(JsonSaveOptions.DisableFormatting) :> obj
             | false ->
                 let t = getTargetType t jsonField
-                let t =
-                    match t with
-                    | t when t = typeof<obj> -> getJsonValueType jvalue
-                    | t -> t 
+                let t = getUntypedType path t jvalue
                 let jvalue =
                     match t with
                     | t when t = typeof<int> ->
@@ -256,6 +318,8 @@ module internal Core =
                         JsonValueHelpers.getBool path jvalue :> obj
                     | t when t = typeof<string> ->
                         JsonValueHelpers.getString path jvalue :> obj
+                    | t when t = typeof<char> ->
+                        JsonValueHelpers.getChar path jvalue :> obj
                     | t when t = typeof<DateTime> ->
                         JsonValueHelpers.getDateTime CultureInfo.InvariantCulture path jvalue :> obj
                     | t when t = typeof<DateTimeOffset> ->

src/FSharp.Json/Interface.fs

@@ -28,13 +28,12 @@ module Json =
     /// Serailizes F# object into JSON. Uses provided [JsonConfig].
     let serializeEx (config: JsonConfig) (theobj: obj): string =
         let json = Core.serialize config (theobj.GetType()) theobj
-        json.ToString()
+        let saveOptions =
+            match config.unformatted with
+            | true -> JsonSaveOptions.DisableFormatting
+            | false -> JsonSaveOptions.None
+        json.ToString(saveOptions)
 
-    /// Serailizes F# object into unformatted JSON. Uses provided [JsonConfig].
-    let serializeExU (config: JsonConfig) (theobj: obj): string =
-        let json = Core.serialize config (theobj.GetType()) theobj
-        json.ToString(JsonSaveOptions.DisableFormatting)
-    
     /// Deserailizes JSON into F# type provided as generic parameter. Uses provided [JsonConfig].
     let deserializeEx<'T> (config: JsonConfig) (json: string): 'T =
         let value = JsonValue.Parse(json)
@@ -44,7 +43,9 @@ module Json =
     let serialize (theobj: obj) = serializeEx JsonConfig.Default theobj
 
     /// Serailizes F# object into unformatted JSON. Uses default [JsonConfig].
-    let serializeU (theobj: obj) = serializeExU JsonConfig.Default theobj
+    let serializeU (theobj: obj) =
+        let config = JsonConfig.create(unformatted = true)
+        serializeEx config theobj
 
     /// Deserailizes JSON into F# type provided as generic parameter. Uses default [JsonConfig].
     let deserialize<'T> (json: string) = deserializeEx<'T> JsonConfig.Default json