Merge pull request #6 from Barberrrry/master

Handle embedded struct fields and slice of any type

Author: mcuadros

README.md

@@ -26,11 +26,21 @@ import (
   "github.com/mcuadros/go-jsonschema-generator"
 )
 
+type EmbeddedType struct {
+  Zoo string
+}
+
+type Item struct {
+  Value string
+}
+
 type ExampleBasic struct {
   Foo bool   `json:"foo"`
   Bar string `json:",omitempty"`
   Qux int8
   Baz []string
+  EmbeddedType
+  List []Item
 }
 
 func main() {
@@ -54,17 +64,36 @@ func main() {
                 "type": "string"
             }
         },
+        "List": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "Value": {
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "Value"
+                ]
+            }
+        },
         "Qux": {
             "type": "integer"
         },
+        "Zoo": {
+            "type": "string"
+        },
         "foo": {
-            "type": "bool"
+            "type": "boolean"
         }
     },
     "required": [
         "foo",
         "Qux",
-        "Baz"
+        "Baz",
+        "Zoo",
+        "List"
     ]
 }
 ```

example/simple.go

@@ -2,14 +2,24 @@ package main
 
 import (
 	"fmt"
-	"github.com/mcuadros/go-jsonschema-generator"
+	"github.com/Barberrrry/go-jsonschema-generator"
 )
 
+type EmbeddedType struct {
+	Zoo string
+}
+
+type Item struct {
+	Value string
+}
+
 type ExampleBasic struct {
 	Foo bool   `json:"foo"`
 	Bar string `json:",omitempty"`
 	Qux int8
 	Baz []string
+	EmbeddedType
+	List []Item
 }
 
 func main() {

jsonschema.go

@@ -45,16 +45,12 @@ func (d *Document) String() string {
 type property struct {
 	Type                 string               `json:"type,omitempty"`
 	Format               string               `json:"format,omitempty"`
-	Items                *item                `json:"items,omitempty"`
+	Items                *property            `json:"items,omitempty"`
 	Properties           map[string]*property `json:"properties,omitempty"`
 	Required             []string             `json:"required,omitempty"`
 	AdditionalProperties bool                 `json:"additionalProperties,omitempty"`
 }
 
-type item struct {
-	Type string `json:"type,omitempty"`
-}
-
 func (p *property) read(t reflect.Type, opts tagOptions) {
 	jsType, format, kind := getTypeFromMapping(t)
 	if jsType != "" {
@@ -81,7 +77,8 @@ func (p *property) readFromSlice(t reflect.Type) {
 	if kind == reflect.Uint8 {
 		p.Type = "string"
 	} else if jsType != "" {
-		p.Items = &item{Type: jsType}
+		p.Items = &property{}
+		p.Items.read(t.Elem(), tagOptions(""))
 	}
 }
 
@@ -114,6 +111,18 @@ func (p *property) readFromStruct(t reflect.Type) {
 			continue
 		}
 
+		if field.Anonymous {
+			embeddedProperty := &property{}
+			embeddedProperty.read(field.Type, opts)
+
+			for name, property := range embeddedProperty.Properties {
+				p.Properties[name] = property
+			}
+			p.Required = append(p.Required, embeddedProperty.Required...)
+
+			continue
+		}
+
 		p.Properties[name] = &property{}
 		p.Properties[name].read(field.Type, opts)
 

jsonschema_test.go

@@ -86,9 +86,14 @@ func (self *propertySuite) TestLoadWithTag(c *C) {
 	})
 }
 
+type SliceStruct struct {
+	Value string
+}
+
 type ExampleJSONBasicSlices struct {
 	Slice            []string      `json:",foo,omitempty"`
 	SliceOfInterface []interface{} `json:",foo"`
+	SliceOfStruct    []SliceStruct
 }
 
 func (self *propertySuite) TestLoadSliceAndContains(c *C) {
@@ -102,14 +107,26 @@ func (self *propertySuite) TestLoadSliceAndContains(c *C) {
 			Properties: map[string]*property{
 				"Slice": &property{
 					Type:  "array",
-					Items: &item{Type: "string"},
+					Items: &property{Type: "string"},
 				},
 				"SliceOfInterface": &property{
 					Type: "array",
 				},
+				"SliceOfStruct": &property{
+					Type: "array",
+					Items: &property{
+						Type:     "object",
+						Required: []string{"Value"},
+						Properties: map[string]*property{
+							"Value": &property{
+								Type: "string",
+							},
+						},
+					},
+				},
 			},
 
-			Required: []string{"SliceOfInterface"},
+			Required: []string{"SliceOfInterface", "SliceOfStruct"},
 		},
 	})
 }
@@ -142,6 +159,30 @@ func (self *propertySuite) TestLoadNested(c *C) {
 	})
 }
 
+type EmbeddedStruct struct {
+	Foo string
+}
+
+type ExampleJSONEmbeddedStruct struct {
+	EmbeddedStruct
+}
+
+func (self *propertySuite) TestLoadEmbedded(c *C) {
+	j := &Document{}
+	j.Read(&ExampleJSONEmbeddedStruct{})
+
+	c.Assert(*j, DeepEquals, Document{
+		Schema: "http://json-schema.org/schema#",
+		property: property{
+			Type: "object",
+			Properties: map[string]*property{
+				"Foo": &property{Type: "string"},
+			},
+			Required: []string{"Foo"},
+		},
+	})
+}
+
 type ExampleJSONBasicMaps struct {
 	Maps           map[string]string `json:",omitempty"`
 	MapOfInterface map[string]interface{}
@@ -181,7 +222,7 @@ func (self *propertySuite) TestLoadNonStruct(c *C) {
 		Schema: "http://json-schema.org/schema#",
 		property: property{
 			Type:  "array",
-			Items: &item{Type: "string"},
+			Items: &property{Type: "string"},
 		},
 	})
 }