PlantUML Class Diagram Generator for golang projects

Overview

godoc reference Go Report Card codecov License: MIT GitHub release Build Status Mentioned in Awesome Go DUMELS Diagram

GoPlantUML

PlantUML Class Diagram Generator for golang projects. Generates class diagram text compatible with plantuml with the information of all structures and interfaces as well as the relationship among them.

Want to try it on your code?

Take a look at www.dumels.com. We have created dumels using this library.

Code of Conduct

Please, review the code of conduct here.

Prerequisites

golang 1.10 or above

Installing

go get github.com/jfeliu007/goplantuml/parser
go get github.com/jfeliu007/goplantuml/cmd/goplantuml
cd $GOPATH/src/github.com/jfeliu007/goplantuml
go install ./...

This will install the command goplantuml in your GOPATH bin folder.

Usage

goplantuml [-recursive] path/to/gofiles path/to/gofiles2
goplantuml [-recursive] path/to/gofiles path/to/gofiles2 > diagram_file_name.puml
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
        hides fields
  -hide-methods
        hides methods
  -ignore string
        comma separated list of folders to ignore
  -notes string
        Comma separated list of notes to be added to the diagram
  -output string
        output file path. If omitted, then this will default to standard output
  -recursive
        walk all directories recursively
  -show-aggregations
        renders public aggregations even when -hide-connections is used (do not render by default)
  -show-aliases
        Shows aliases even when -hide-connections is used
  -show-compositions
        Shows compositions even when -hide-connections is used
  -show-connection-labels
        Shows labels in the connections to identify the connections types (e.g. extends, implements, aggregates, alias of
  -show-implementations
        Shows implementations even when -hide-connections is used
  -show-options-as-note
        Show a note in the diagram with the none evident options ran with this CLI
  -title string
        Title of the generated diagram

Example

goplantuml $GOPATH/src/github.com/jfeliu007/goplantuml/parser
// echoes

@startuml
namespace parser {
    class Struct {
        + Functions []*Function
        + Fields []*Parameter
        + Type string
        + Composition []string
        + Extends []string

    }
    class LineStringBuilder {
        + WriteLineWithDepth(depth int, str string) 

    }
    class ClassParser {
        - structure <font color=blue>map</font>[string]<font color=blue>map</font>[string]*Struct
        - currentPackageName string
        - allInterfaces <font color=blue>map</font>[string]<font color=blue>struct</font>{}
        - allStructs <font color=blue>map</font>[string]<font color=blue>struct</font>{}

        - structImplementsInterface(st *Struct, inter *Struct) 
        - parsePackage(node ast.Node) 
        - parseFileDeclarations(node ast.Decl) 
        - addMethodToStruct(s *Struct, method *ast.Field) 
        - getFunction(f *ast.FuncType, name string) 
        - addFieldToStruct(s *Struct, field *ast.Field) 
        - addToComposition(s *Struct, fType string) 
        - addToExtends(s *Struct, fType string) 
        - getOrCreateStruct(name string) 
        - getStruct(structName string) 
        - getFieldType(exp ast.Expr, includePackageName bool) 

        + Render() 

    }
    class Parameter {
        + Name string
        + Type string

    }
    class Function {
        + Name string
        + Parameters []*Parameter
        + ReturnValues []string

    }
}
strings.Builder *-- parser.LineStringBuilder


@enduml
goplantuml $GOPATH/src/github.com/jfeliu007/goplantuml/parser > ClassDiagram.puml
// Generates a file ClassDiagram.plum with the previous specifications

There are two different relationships considered in goplantuml:

  • Interface implementation
  • Type Composition

The following example contains interface implementations and composition. Notice how the signature of the functions

package testingsupport

//MyInterface only has one method, notice the signature return value
type MyInterface interface {
	foo() bool
}

//MyStruct1 will implement the foo() bool function so it will have an "extends" association with MyInterface
type MyStruct1 struct {
}

func (s1 *MyStruct1) foo() bool {
	return true
}

//MyStruct2 will be directly composed of MyStruct1 so it will have a composition relationship with it
type MyStruct2 struct {
	MyStruct1
}

//MyStruct3 will have a foo() function but the return value is not a bool, so it will not have any relationship with MyInterface
type MyStruct3 struct {
    Foo MyStruct1
}

func (s3 *MyStruct3) foo() {

}

This will be generated from the previous code

@startuml
namespace testingsupport {
    interface MyInterface  {
        - foo() bool

    }
    class MyStruct1 << (S,Aquamarine) >> {
        - foo() bool

    }
    class MyStruct2 << (S,Aquamarine) >> {
    }
    class MyStruct3 << (S,Aquamarine) >> {
        - foo() 

        + Foo MyStruct1

    }
}
testingsupport.MyStruct1 *-- testingsupport.MyStruct2

testingsupport.MyInterface <|-- testingsupport.MyStruct1

testingsupport.MyStruct3 o-- testingsupport.MyStruct1

@enduml

alt text

Diagram using www.dumels.com

UML Diagram

Comments
  • Repeatable output (idempotent output)

    Repeatable output (idempotent output)

    goplantuml should generate identical output when repeatedly executed against identical inputs/targets.

    For example, when running the following 3 commands, the diff should detect no differences.

    goplantuml -recursive . > goplantuml.a.puml
    goplantuml -recursive . > goplantuml.b.puml
    diff goplantuml.a.puml goplantuml.b.puml
    

    However, currently the diff detects many differences between the 2 files.

    Such non-idempotent output makes the output less usable for a variety of purposes. For example:

    • Since the diagram layout may potentially be affected by the order in which Classes and edges are defined in the output, plantuml/graphviz may potentially render different diagrams for output generated from identical source code (e.g. the 2 puml files generated above).
    • If output is committed to SCM, reviewing changes is nearly impossible (with the current non-idempotent output).
    • If output is manually modified (and then committed), it is more difficult to retain the manual revisions when updating the file (using goplantuml) when the underlying packages' source code changes.
    • It is more difficult to review the effects on the output of any CLI options that modify the output (e.g. #51, #53, #54, #55, #56, #57, #58, #60).

    And if there is some reason or benefit from the current behavior (i.e. randomized output), then a new CLI flag could be added to give the user a choice between idempotent vs randomized output. However, I think that idempotent output should be the default behavior.

    enhancement 
    opened by Justin-W 16
  • Invalid edge for type

    Invalid edge for type

    I'm seeing the following invalid puml generated:

    <font color=blue>func</font>() []*servicebridgeerrors.Error #.. utils.StructureValidatorMethod
    

    I think the go code that is causing the above line is this:

    type StructureValidatorMethod func(interface{}) []*servicebridgeerrors.Error
    
    bug 
    opened by Justin-W 12
  • Struct Fields are not part of the diagram

    Struct Fields are not part of the diagram

    Hi there!

    First of all, nice work, like the idea of this repo!

    I noticed, that this code looks like this:

    image

    But I would have expected something like this:

    image

    which would correspond to this PlantUML:

    @startuml
    namespace plantuml {
        class Phone << (S,Aquamarine) >> {
            + Value string
            + IsMobile bool
    
        }
        class Person << (S,Aquamarine) >> {
            + Birthday Birthday
            + Phones []Phone
    
        }
        class Birthday << (S,Aquamarine) >> {
            + Time time.Time
    
        }
        Phone <|-- Person
        Birthday <|-- Person
    }
    @enduml
    

    I would like to use this tool to create a quick ERD for an upcoming project. And doing this by code enables me to quickly generate these models.

    My proposal:

    If displaying links based on struct fields is not considered a standard, could this at least be added as an CLI option?

    enhancement 
    opened by FabianTe 7
  • Composition doesn't work

    Composition doesn't work

    If I try to run the example in the README.md, the composition with MyStruct3 is not rendered (using go v1.12.6):

    XL713e8m3BtlAte45HFnkX2yc7ZWn1TC78O4rhbr1wBykymOqG3IKzFszRtNffQ48TVKJ8b6MYqA2IGjLUfgdTPe2EuC-YXgOIraRKx65RG3pY78DuUR4uqmbP8X9Cbxr4S49M8GmXcnPgzgDx4c_hTc2h1Vubt34N6GoKQ2liLKYgGflUMiFNto1HST-xtFThZ9AefWfXcpCMoWv8zvPEyXbUhYN_G4

    How to reproduce

    save the following to a file:

    package testingsupport
    
    //MyInterface only has one method, notice the signature return value
    type MyInterface interface {
    	foo() bool
    }
    
    //MyStruct1 will implement the foo() bool function so it will have an "extends" association with MyInterface
    type MyStruct1 struct {
    }
    
    func (s1 *MyStruct1) foo() bool {
    	return true
    }
    
    //MyStruct2 will be direclty composed of MyStruct1 so it will have a composition relationship with it
    type MyStruct2 struct {
    	MyStruct1
    }
    
    //MyStruct3 will have a foo() function but the return value is not a bool, so it will not have any relationship with MyInterface
    type MyStruct3 struct {
        Foo MyStruct1
    }
    
    func (s3 *MyStruct3) foo() {
    
    }
    

    Then generate the plantuml:

    goplantuml ./
    

    The diagram I get is the following:

    @startuml
    namespace testingsupport {
        interface MyInterface  {
            - foo() bool
    
        }
        class MyStruct1 << (S,Aquamarine) >> {
            - foo() bool
    
        }
        class MyStruct2 << (S,Aquamarine) >> {
        }
        class MyStruct3 << (S,Aquamarine) >> {
            + Foo MyStruct1
    
            - foo() 
    
        }
    }
    testingsupport.MyStruct1 *-- testingsupport.MyStruct2
    
    testingsupport.MyInterface <|-- testingsupport.MyStruct1
    
    @enduml
    
    opened by nkcr 6
  • Enhancement: Render Header/Title and/or Legend

    Enhancement: Render Header/Title and/or Legend

    It'd be very helpful if the rendered puml diagram included a diagram title and/or a diagram-level legend (maybe a puml note?) with info about the diagram.

    Optionally, 1+ new CLI flag could be added to disable the title, legend, etc. (in full and/or in part).

    Suggested Diagram Metadata

    • Diagram Title E.g. Something related to the target golang package's full import path.
    • Render-time info (e.g. date/time rendered)
    • Rendering options E.g. Indicating any non-default rendering options were used to render the diagram (but possibly excluding any self-evident options, such as -label-edges).
    • (optionally) Git-related info (e.g. git branch that was rendered)

    Rationale

    When generating multiple diagrams (for different packages, or for the same package but with different CLI options, such as with and without -recursive or -hide-fields), the diagrams' contents are currently ambiguous, because they don't indicate whether content (subpackages, edges, fields, etc.) that is missing from the diagram is missing because of goplantuml CLI options, or because of the underlying package's source code.

    With the above items included (automatically by default or via optional CLI flag) in each diagram's rendered content, the generated diagram's content would be self-documenting, unambiguous, and useful as a standalone design or review artifact.

    Also, having goplantuml render the Title, Legend, etc. would prevent the need for post-rendering manual addition of such info, and also allow goplantuml to retain control over the formatting and content of the Title and Legend (e.g. when a new CLI flag is added to goplantuml, you would be able to decide what effect, if any, it should have on the Title and Legend).

    However, retaining the ability to disable/hide the Title, Legend, etc. would be good, since it would allow generated diagrams to be included in documents, web pages, etc. which might want to control captions, titles, etc. separately from the diagram's image file.

    enhancement 
    opened by Justin-W 6
  • Enhancement: Additional CLI options to control rendered output

    Enhancement: Additional CLI options to control rendered output

    It would be nice if the cmd class supported some additional CLI flags to enable the CLI to be used to quickly generate common variations of the current output.

    The benefit of having CLI flags such as the following would be that someone could easily render several different diagrams/graphs of the same golang package(s), since each variant diagram has different PROs and CONs as an exploratory (and/or explanatory) visualization.

    Suggested rendering options:

    • -no-fields: to hide/exclude Classes' "fields" This would be useful for simplifying/filtering the output. E.g. Reducing the size of the Class nodes (by including less intra-Class detail) simplifies the graph layout, and makes it easier to trace inter-Class relationships during an API review of the coupling between Classes.
    • -no-methods: to hide/exclude Classes' "methods" Same rationale as previous, but for methods/functions instead of fields.
    • -no-fields -no-methods: to hide/exclude all inner members of Classes Same rationale as previous, but for both methods/functions and fields. Hiding all intra-Class detail makes the graph much easier to use for identifying inter-Class coupling, etc.
    • -no-edges: to hide/exclude all edges This would be useful to allow the output to be used as a template. E.g. So that custom edges can be added manually, but without having to manually remove all of the default edges. Also, since edges impact diagram layout (Class location), temporarily eliminating the edges can be useful for simplifying graph layout (e.g. to locate a particular Class/node).
    • -no-edgeless: to hide/exclude all Classes without any edges/arrows This would be useful for simplifying/filtering the output. E.g. To easily exclude un-connected Classes during an API review of the coupling between Classes. (When there are many un-connected Classes, they can clutter up the diagram making it harder to trace the relationships between the connected Classes.)
    • -only-edgeless: to hide/exclude all Classes with any edges/arrows This would be useful for simplifying/filtering the output. E.g. To easily identify un-connected Classes during an API review. (E.g. Un-connected Classes often get 'scattered', with seemingly haphazard locations, based on where they 'fit' between connected Classes and their edges/arrows. Hiding edges and/or edged-Classes can reduce or eliminate such haphazard layouts, which is useful in certain situations.)
    • -label-edges: to include text labels on all rendered edges/arrows This would make arrows with different heads/tails easier to distinguish from each other. (E.g. When multiple edges all start or end at the same Class, it can be difficult to identify which head/tail type a particular arrow has.)

    Note: For all of the hiding/filtering options above, you have 2 implementation options: either exclude 'hidden' graph content from the output completely, OR render the hidden content as you normally would, except as commented-out puml (so the diagram rendering would ignore hidden content, but the hidden content could be selectively un-hidden manually). Or you could give the user the choice between those 2 options by adding an additional -excluded-as-comments CLI flag (or similar).

    Related: Similar to enhancement #28, but for additional CLI switches.

    enhancement 
    opened by Justin-W 6
  • Testing and Logs

    Testing and Logs

    Hi,

    First of all this is an excellent go-uml tool. Thanks for this awesome work.

    One issue: I generated a puml file. But when I pasted in server, it fails to show any output. Then I had to change the puml file going through syntax and all to make this work. Is it possible to automate this just as to start a puml server instance locally and run this at once. And if display is failing, what could be the issues? Right now I don't even see any logs either.

    Regards, Sandip

    opened by sasahoo 6
  • Support for parenthesized type declarations

    Support for parenthesized type declarations

    I had several parenthesized interface type declarations and noticed they weren't showing up in the puml output.

    Examples) Works:

    type Foo interface {
      Foo()
    }
    type Bar interface {
      Bar()
    }
    

    Not working:

    type (
      Foo interface {
        Foo()
      }
      Bar interface {
        Bar()
      }
    )
    
    opened by rlankfo 4
  • Extended Interface not correctly visualized

    Extended Interface not correctly visualized

    The code from the golang.org website:

    package main
    
    type ReadWriter interface {
    	Read(b Buffer) bool
    	Write(b Buffer) bool
    }
    
    type File interface {
    	ReadWriter  // same as adding the methods of ReadWriter
    	Locker      // same as adding the methods of Locker
    	Close()
    }
    
    type LockedFile interface {
    	Locker
    	File        // illegal: Lock, Unlock not unique
    	Lock()      // illegal: Lock not unique
    }
    

    leads to the following uml code:

    @startuml
    namespace main {
        interface ReadWriter  {
            + Read(b Buffer) bool
            + Write(b Buffer) bool
    
        }
        interface File  {
            + Close() 
    
        }
        interface LockedFile  {
            + Lock() 
    
        }
    }
    
    
    @enduml
    

    I think there should be some kind of extend or maybe a copy of all the methods from ReadWriter/Locker to File.

    bug 
    opened by thomase1993 4
  • How to generate the UML diagram?

    How to generate the UML diagram?

    Hi @jfeliu007,

    I have created the .puml file but I'm not quite getting what command should I run to generate the UML diagram. Please help me with this.

    Thanks.

    opened by aggarwalanubhav 3
  • fix typo and add newline to error messages

    fix typo and add newline to error messages

    This PR addresses issue #93:

    • appends a newline to the following error message paths
      • could not find directory
      • is not a directory

    • fixes typo with output, goplantum -> goplantuml
    opened by MorrisLaw 3
  • Parser Panic

    Parser Panic

    Hello, when I run the tool, the parser raises the following panic and error. A blank puml file is generated at the end.

    % goplantuml -show-aggregations -show-implementations -show-compositions -recursive . > diagram_file_name.puml
    panic: runtime error: index out of range [0] with length 0
    
    goroutine 1 [running]:
    github.com/jfeliu007/goplantuml/parser.(*ClassParser).handleFuncDecl(0x140000281e0, 0x1400016e720)
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/parser/class_parser.go:279 +0x3f4
    github.com/jfeliu007/goplantuml/parser.(*ClassParser).parseFileDeclarations(0x140000281e0?, {0x104fadb60?, 0x1400016e720?})
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/parser/class_parser.go:265 +0x98
    github.com/jfeliu007/goplantuml/parser.(*ClassParser).parsePackage(0x140000281e0, {0x104fad218?, 0x1400016e390})
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/parser/class_parser.go:233 +0x344
    github.com/jfeliu007/goplantuml/parser.(*ClassParser).parseDirectory(0x0?, {0x140000242a0, 0x56})
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/parser/class_parser.go:254 +0xac
    github.com/jfeliu007/goplantuml/parser.NewClassDiagramWithOptions.func1({0x140000242a0, 0x56}, {0x104fae7f8, 0x1400007fba0}, {0x0?, 0x0?})
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/parser/class_parser.go:169 +0x11c
    github.com/spf13/afero.walk({0x104faea10, 0x1050e9de8}, {0x140000242a0, 0x56}, {0x104fae7f8, 0x1400007fba0}, 0x140001b3a90)
            PATH/go/pkg/mod/github.com/spf13/[email protected]/path.go:44 +0x5c
    github.com/spf13/afero.Walk({0x104faea10, 0x1050e9de8}, {0x140000242a0, 0x56}, 0x1400012fa90)
            PATH/go/pkg/mod/github.com/spf13/[email protected]/path.go:105 +0x88
    github.com/jfeliu007/goplantuml/parser.NewClassDiagramWithOptions(0x140001b3c48)
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/parser/class_parser.go:158 +0x208
    github.com/jfeliu007/goplantuml/parser.NewClassDiagram({0x14000060e30?, 0x1400012fe68?, 0x8?}, {0x1050e9de8?, 0x0?, 0x1f?}, 0x47?)
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/parser/class_parser.go:209 +0x7c
    main.main()
            PATH/go/pkg/mod/github.com/jfeliu007/[email protected]/cmd/goplantuml/main.go:102 +0xc10
    
    opened by erdemtuna 0
  • Added go-recipes badge

    Added go-recipes badge

    Hello, Hi!! 👋🏻

    I like your project and I think broader Go community will benefit from it too.

    Thus, I added it to the curated list of Go tools.

    I hope this badge will serve as a mark of quality and appreciation to your project.

    Once again, thank you for your work!!

    ❤️

    -- Nikolay

    opened by nikolaydubina 0
  • Visualize single function as a functor

    Visualize single function as a functor

    I know functions is not considered as a class per se, but based on this, we could use a stereotype « function » on a class to create isolated functions. As an option, it could help dig into the big functions that needs maybe splitting if they are gathering too many arrows on it?

    opened by dolanor 0
Releases(v1.6.1)
  • v1.6.1(Apr 6, 2022)

    What's Changed

    • Support for parenthesized type declarations by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/107
    • Adds a -hide-private-members flag by @weters in https://github.com/jfeliu007/goplantuml/pull/110
    • Fix error from named imports and anonymous fields by @csams in https://github.com/jfeliu007/goplantuml/pull/124
    • Add github action to the repo by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/130
    • Fix return parametrized error and added go Mod. by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/128
    • Updated install instructions to "go install" per issue 119 by @Heidelberger in https://github.com/jfeliu007/goplantuml/pull/126
    • Changed to version 2. by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/133
    • Added folder structure for version 2. by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/134
    • Restructured folders for v2 by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/135
    • revert back to v1 in the go mods by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/138

    New Contributors

    • @weters made their first contribution in https://github.com/jfeliu007/goplantuml/pull/110
    • @csams made their first contribution in https://github.com/jfeliu007/goplantuml/pull/124
    • @Heidelberger made their first contribution in https://github.com/jfeliu007/goplantuml/pull/126

    Full Changelog: https://github.com/jfeliu007/goplantuml/compare/v1.5.2...v1.6.1

    Source code(tar.gz)
    Source code(zip)
  • v1.6.0(Apr 6, 2022)

    What's Changed

    • Support for parenthesized type declarations by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/107
    • Adds a -hide-private-members flag by @weters in https://github.com/jfeliu007/goplantuml/pull/110
    • Fix error from named imports and anonymous fields by @csams in https://github.com/jfeliu007/goplantuml/pull/124
    • Add github action to the repo by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/130
    • Fix return parametrized error and added go Mod. by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/128
    • Updated install instructions to "go install" per issue 119 by @Heidelberger in https://github.com/jfeliu007/goplantuml/pull/126
    • Changed to version 2. by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/133
    • Added folder structure for version 2. by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/134
    • Restructured folders for v2 by @jfeliu007 in https://github.com/jfeliu007/goplantuml/pull/135

    New Contributors

    • @weters made their first contribution in https://github.com/jfeliu007/goplantuml/pull/110
    • @csams made their first contribution in https://github.com/jfeliu007/goplantuml/pull/124
    • @Heidelberger made their first contribution in https://github.com/jfeliu007/goplantuml/pull/126

    Full Changelog: https://github.com/jfeliu007/goplantuml/compare/v1.5.2...v1.6.0

    Source code(tar.gz)
    Source code(zip)
  • v1.5.1(Sep 14, 2020)

  • v1.5.0(May 13, 2020)

    Added two new CLI options -output (to specify an output file) -aggregate-private-members (To make aggregations for private members also render)

    Source code(tar.gz)
    Source code(zip)
  • v1.4.0(Nov 26, 2019)

  • v1.3.0(Oct 26, 2019)

  • v1.2.2(Oct 25, 2019)

  • v1.2.1(Oct 22, 2019)

  • v1.2.0(Oct 22, 2019)

  • v1.1.1(Oct 18, 2019)

  • v1.1.0(Oct 18, 2019)

    This release includes issues #29 and #28 . Which basically adds support for parsing different directories and ignoring others. The CLI was also updated to reflect this new capability.

    Source code(tar.gz)
    Source code(zip)
  • v1.0.2(Sep 25, 2019)

  • v1.0.1(Jul 15, 2019)

  • v1.0.0(Jul 12, 2019)

Owner
Javier Feliu
Performance is King
Javier Feliu
Clean architecture validator for go, like a The Dependency Rule and interaction between packages in your Go projects.

Clean Architecture checker for Golang go-cleanarch was created to keep Clean Architecture rules, like a The Dependency Rule and interaction between mo

Robert Laszczak 637 Dec 1, 2022
Find outdated golang packages

This project is not supported anymore Go-outdated is minimalistic library that helps to find outdated packages hosted on github.com in your golang pro

null 44 Sep 27, 2022
Golang AST visualizer

GoAst Viewer Golang AST visualizer. Demo GoAst Viewer Demo Usage You just need to run a http server and open your browser to index.html Installation T

Tomohito Ozaki 670 Dec 2, 2022
A golang formatter that fixes long lines

golines Golines is a golang formatter that shortens long lines, in addition to all of the formatting fixes done by gofmt. Motivation The standard gola

Segment 515 Dec 3, 2022
A Golang tool that does static analysis, unit testing, code review and generate code quality report.

goreporter A Golang tool that does static analysis, unit testing, code review and generate code quality report. This is a tool that concurrently runs

360 Enterprise Security Group, Endpoint Security, inc. 3k Dec 7, 2022
Know when GC runs from inside your golang code

gcnotifier gcnotifier provides a way to receive notifications after every run of the garbage collector (GC). Knowing when GC runs is useful to instruc

Carlo Alberto Ferraris 172 Nov 29, 2022
a simple golang SSA viewer tool use for code analysis or make a linter

ssaviewer A simple golang SSA viewer tool use for code analysis or make a linter ssa.html generate code modify from src/cmd/compile/internal/ssa/html.

null 7 May 17, 2022
The Golang linter that checks that there is no simultaneous return of `nil` error and an invalid value.

nilnil Checks that there is no simultaneous return of nil error and an invalid value. Installation & usage $ go install github.com/Antonboom/[email protected]

Anton Telyshev 12 Aug 30, 2022
API em Golang utilizando clean architecture

Clean Arch in Go Read about Clean Architecture Build make Run tests make te

Marcos 1 Dec 23, 2021
Generate PlantUML ER diagram textual description from PostgreSQL tables

Generate PlantUML ER diagram textual description from PostgreSQL tables

Akira Chiku 478 Nov 29, 2022
Converts a trace of Datadog to a sequence diagram of PlantUML (Currently, supports only gRPC)

jigsaw Automatically generate a sequence diagram from JSON of Trace in Datadog. ⚠️ Only gRPC calls appear in the sequence diagram. Example w/ response

Yu SERIZAWA 6 Jul 12, 2022
GR 4 - Wow class generator

Wow class generator Simple generator to create maps in Go using warcraft logs for Class and Spec Names. It generates : A dict of current wow classes a

Hetic MT Promotion 2021 0 Nov 5, 2021
Generate plantuml diagrams from go source files or directories

go-plantuml go-plantuml generates plantuml diagrams from go source files or directories. Installation go get -u github.com/bykof/go-plantuml Please co

Michael Bykovski 282 Dec 2, 2022
Generate plantuml diagrams from go source files or directories

go-plantuml go-plantuml generates plantuml diagrams from go source files or directories. Installation go get -u github.com/bykof/go-plantuml Please co

Michael Bykovski 283 Dec 5, 2022
Generate PlantUML diagrams from Chrome or Firefox network inspections

hoofli Generate PlantUML diagrams from Chrome or Firefox network inspections This tool reads browser HAR files stored on your local disk and transform

Pascal Dennerly 6 Nov 15, 2022
API for generate sequence diagram

Gen-sequence-diagram API for generate sequence diagram Requirements Golang 1.17+ Endpoint Method Router Request Body POST http://localhost:8080/ {"for

Eder Costa 0 Jan 4, 2022
Dj13SDDownloader - command line downloader sequence diagram

dj13SDDownloader command line downloader sequence diagram from https://sequence.davidje13.com/ Download Download Link curl https://github.com/xh-dev-g

null 0 Jan 2, 2022
GoFrame is a modular, powerful, high-performance and enterprise-class application development framework of Golang.

GoFrame English | 简体中文 GoFrame is a modular, powerful, high-performance and enterprise-class application development framework of Golang. If you're a

GoFrame 8.6k Nov 29, 2022
Exercise project written in Go that I did on my own during the course "gRPC [Golang] Master Class: Build Modern API & Microservices" taught by Stephane Maarek on Udemy

calculator Exercise project written in Go that I did on my own during the course "gRPC [Golang] Master Class: Build Modern API & Microservices" taught

Marco Julián Torre 0 Nov 9, 2022