Merge pull request #98 from jfeliu007/issue-97

issue-97 - Generate relation for private fields

Author: jfeliu007

README.md

@@ -33,6 +33,8 @@ goplantuml [-recursive] path/to/gofiles path/to/gofiles2 > diagram_file_name.pum
 ```
 ```
 Usage of goplantuml:
+  -aggregate-private-members
+        Show aggregations for private members. Ignored if -show-aggregations is not used.
   -hide-connections
         hides all connections in the diagram
   -hide-fields

cmd/goplantuml/main.go

@@ -47,14 +47,15 @@ func main() {
 	notes := flag.String("notes", "", "Comma separated list of notes to be added to the diagram")
 	output := flag.String("output", "", "output file path. If omitted, then this will default to standard output")
 	showOptionsAsNote := flag.Bool("show-options-as-note", false, "Show a note in the diagram with the none evident options ran with this CLI")
-
+	aggregatePrivateMembers := flag.Bool("aggregate-private-members", false, "Show aggregations for private members. Ignored if -show-aggregations is not used.")
 	flag.Parse()
 	renderingOptions := map[goplantuml.RenderingOption]interface{}{
-		goplantuml.RenderConnectionLabels: *showConnectionLabels,
-		goplantuml.RenderFields:           !*hideFields,
-		goplantuml.RenderMethods:          !*hideMethods,
-		goplantuml.RenderAggregations:     *showAggregations,
-		goplantuml.RenderTitle:            *title,
+		goplantuml.RenderConnectionLabels:  *showConnectionLabels,
+		goplantuml.RenderFields:            !*hideFields,
+		goplantuml.RenderMethods:           !*hideMethods,
+		goplantuml.RenderAggregations:      *showAggregations,
+		goplantuml.RenderTitle:             *title,
+		goplantuml.AggregatePrivateMembers: *aggregatePrivateMembers,
 	}
 	if *hideConnections {
 		renderingOptions[goplantuml.RenderAliases] = *showAliases
@@ -179,6 +180,8 @@ func getLegend(ro map[goplantuml.RenderingOption]interface{}) (string, error) {
 			result = fmt.Sprintf("%sRender Implementations: %t\n", result, val.(bool))
 		case goplantuml.RenderMethods:
 			result = fmt.Sprintf("%sRender Methods: %t\n", result, val.(bool))
+		case goplantuml.AggregatePrivateMembers:
+			result = fmt.Sprintf("%sPritave Aggregations: %t\n", result, val.(bool))
 		}
 	}
 	return strings.TrimSpace(result), nil

parser/class_parser.go

@@ -60,15 +60,16 @@ type ClassDiagramOptions struct {
 
 //RenderingOptions will allow the class parser to optionally enebale or disable the things to render.
 type RenderingOptions struct {
-	Title            string
-	Notes            string
-	Aggregations     bool
-	Fields           bool
-	Methods          bool
-	Compositions     bool
-	Implementations  bool
-	Aliases          bool
-	ConnectionLabels bool
+	Title                   string
+	Notes                   string
+	Aggregations            bool
+	Fields                  bool
+	Methods                 bool
+	Compositions            bool
+	Implementations         bool
+	Aliases                 bool
+	ConnectionLabels        bool
+	AggregatePrivateMembers bool
 }
 
 const aliasComplexNameComment = "'This class was created so that we can correctly have an alias pointing to this name. Since it contains dots that can break namespaces"
@@ -100,6 +101,9 @@ const RenderTitle = 7
 //RenderNotes contains a list of notes to be rendered in the class diagram
 const RenderNotes = 8
 
+//AggregatePrivateMembers is to be used in the SetRenderingOptions argument as the key to the map, when value is true, it will connect aggregations with private members
+const AggregatePrivateMembers = 9
+
 //RenderingOption is an alias for an it so it is easier to use it as options in a map (see SetRenderingOptions(map[RenderingOption]bool) error)
 type RenderingOption int
 
@@ -530,9 +534,23 @@ func (p *ClassParser) renderCompositions(structure *Struct, name string, composi
 
 func (p *ClassParser) renderAggregations(structure *Struct, name string, aggregations *LineStringBuilder) {
 
-	orderedAggregations := []string{}
+	aggregationMap := structure.Aggregations
+	if p.renderingOptions.AggregatePrivateMembers {
+		p.updatePrivateAggregations(structure, aggregationMap)
+	}
+	p.renderAggregationMap(aggregationMap, structure, aggregations, name)
+}
+
+func (p *ClassParser) updatePrivateAggregations(structure *Struct, aggregationsMap map[string]struct{}) {
+
+	for agg := range structure.PrivateAggregations {
+		aggregationsMap[agg] = struct{}{}
+	}
+}
 
-	for a := range structure.Aggregations {
+func (p *ClassParser) renderAggregationMap(aggregationMap map[string]struct{}, structure *Struct, aggregations *LineStringBuilder, name string) {
+	var orderedAggregations []string
+	for a := range aggregationMap {
 		orderedAggregations = append(orderedAggregations, a)
 	}
 
@@ -626,13 +644,14 @@ func (p *ClassParser) getOrCreateStruct(name string) *Struct {
 	result, ok := p.structure[p.currentPackageName][name]
 	if !ok {
 		result = &Struct{
-			PackageName:  p.currentPackageName,
-			Functions:    make([]*Function, 0),
-			Fields:       make([]*Field, 0),
-			Type:         "",
-			Composition:  make(map[string]struct{}, 0),
-			Extends:      make(map[string]struct{}, 0),
-			Aggregations: make(map[string]struct{}, 0),
+			PackageName:         p.currentPackageName,
+			Functions:           make([]*Function, 0),
+			Fields:              make([]*Field, 0),
+			Type:                "",
+			Composition:         make(map[string]struct{}, 0),
+			Extends:             make(map[string]struct{}, 0),
+			Aggregations:        make(map[string]struct{}, 0),
+			PrivateAggregations: make(map[string]struct{}, 0),
 		}
 		p.structure[p.currentPackageName][name] = result
 	}
@@ -671,6 +690,8 @@ func (p *ClassParser) SetRenderingOptions(ro map[RenderingOption]interface{}) er
 			p.renderingOptions.Title = val.(string)
 		case RenderNotes:
 			p.renderingOptions.Notes = val.(string)
+		case AggregatePrivateMembers:
+			p.renderingOptions.AggregatePrivateMembers = val.(bool)
 		default:
 			return fmt.Errorf("Invalid Rendering option %v", option)
 		}

parser/class_parser_test.go

@@ -90,13 +90,14 @@ func TestGetOrCreateStruct(t *testing.T) {
 			st := parser.getOrCreateStruct(tc.nameToLookFor)
 			if tc.expectedEmpty {
 				if !reflect.DeepEqual(st, &Struct{
-					PackageName:  parser.currentPackageName,
-					Functions:    make([]*Function, 0),
-					Fields:       make([]*Field, 0),
-					Type:         "",
-					Composition:  make(map[string]struct{}, 0),
-					Extends:      make(map[string]struct{}, 0),
-					Aggregations: make(map[string]struct{}, 0),
+					PackageName:         parser.currentPackageName,
+					Functions:           make([]*Function, 0),
+					Fields:              make([]*Field, 0),
+					Type:                "",
+					Composition:         make(map[string]struct{}, 0),
+					Extends:             make(map[string]struct{}, 0),
+					Aggregations:        make(map[string]struct{}, 0),
+					PrivateAggregations: make(map[string]struct{}, 0),
 				}) {
 					t.Errorf("Expected resulting structure to be equal to %v, got %v", tc.structure, st)
 				}
@@ -193,6 +194,8 @@ func TestRenderStructures(t *testing.T) {
 	}
 	st := getTestStruct()
 	st.Aggregations = map[string]struct{}{"File": {}}
+	st.PrivateAggregations = map[string]struct{}{"File": {}}
+	st.PrivateAggregations = map[string]struct{}{"File2": {}}
 	structMap = map[string]*Struct{
 		"MainClass": st,
 	}
@@ -206,6 +209,18 @@ func TestRenderStructures(t *testing.T) {
 	if lineB.String() != expectedResult {
 		t.Errorf("TestRenderStructures: expected %s, got %s", expectedResult, lineB.String())
 	}
+
+	lineB = &LineStringBuilder{}
+	parser = getEmptyParser("main")
+	parser.SetRenderingOptions(map[RenderingOption]interface{}{
+		RenderAggregations:      true,
+		AggregatePrivateMembers: true,
+	})
+	parser.renderStructures("main", structMap, lineB)
+	expectedResult = "namespace main {\n    class MainClass << (S,Aquamarine) >> {\n        - privateField int\n\n        + PublicField error\n\n        - foo( int,  string) (error, int)\n\n        + Boo( string,  int) int\n\n    }\n}\n\"foopack.AnotherClass\" *-- \"main.MainClass\"\n\n\"main.NewClass\" <|-- \"main.MainClass\"\n\n\"main.MainClass\" o-- \"main.File\"\n\"main.MainClass\" o-- \"main.File2\"\n\n"
+	if lineB.String() != expectedResult {
+		t.Errorf("TestRenderStructures: expected %s, got %s", expectedResult, lineB.String())
+	}
 }
 
 func TestRenderStructure(t *testing.T) {

parser/struct.go

@@ -8,13 +8,14 @@ import (
 //Struct represent a struct in golang, it can be of Type "class" or "interface" and can be associated
 //with other structs via Composition and Extends
 type Struct struct {
-	PackageName  string
-	Functions    []*Function
-	Fields       []*Field
-	Type         string
-	Composition  map[string]struct{}
-	Extends      map[string]struct{}
-	Aggregations map[string]struct{}
+	PackageName         string
+	Functions           []*Function
+	Fields              []*Field
+	Type                string
+	Composition         map[string]struct{}
+	Extends             map[string]struct{}
+	Aggregations        map[string]struct{}
+	PrivateAggregations map[string]struct{}
 }
 
 // ImplementsInterface returns true if the struct st conforms ot the given interface
@@ -68,6 +69,11 @@ func (st *Struct) AddToAggregation(fType string) {
 	st.Aggregations[fType] = struct{}{}
 }
 
+//addToPrivateAggregation adds an aggregation type to the list of aggregations for private members
+func (st *Struct) addToPrivateAggregation(fType string) {
+	st.PrivateAggregations[fType] = struct{}{}
+}
+
 //AddField adds a field into this structure. It parses the ast.Field and extract all
 //needed information
 func (st *Struct) AddField(field *ast.Field, aliases map[string]string) {
@@ -84,6 +90,10 @@ func (st *Struct) AddField(field *ast.Field, aliases map[string]string) {
 			for _, t := range fundamentalTypes {
 				st.AddToAggregation(replacePackageConstant(t, st.PackageName))
 			}
+		} else {
+			for _, t := range fundamentalTypes {
+				st.addToPrivateAggregation(replacePackageConstant(t, st.PackageName))
+			}
 		}
 	} else if field.Type != nil {
 		if theType[0] == "*"[0] {

testingsupport/main.go

@@ -10,7 +10,8 @@ func (t *test) test() {
 }
 
 type test struct {
-	field int
+	field  int
+	field2 TestComplicatedAlias
 }
 
 type myInt int

testingsupport/testingsupport.puml

@@ -8,6 +8,7 @@ end legend
 namespace testingsupport {
     class test << (S,Aquamarine) >> {
         - field int
+        - field2 TestComplicatedAlias
 
         - test()