feat!: update Commit struct

Author: muthukrishnan24

commit.go

@@ -2,37 +2,82 @@ package parser
 
 // Commit represents a commit that adheres to the conventional commits specification
 type Commit struct {
-	Header Header
-	Body   string
-	Footer Footer
+	message string
 
-	BreakingChange bool
+	header string
+	body   string
+	footer string
 
-	FullCommit string
+	commitType  string
+	scope       string
+	description string
+	notes       []Note
+
+	isBreakingChange bool
 }
 
-// Header represents Header in commit message
-type Header struct {
-	Type        string
-	Scope       string
-	Description string
+// Message returns input commit message
+func (c *Commit) Message() string {
+	return c.message
+}
 
-	FullHeader string
+// Header returns header of the commit
+func (c *Commit) Header() string {
+	return c.header
 }
 
-// Footer represents Footer in commit message
-type Footer struct {
-	Notes []FooterNote
+// Body returns body of the commit
+func (c *Commit) Body() string {
+	return c.body
+}
+
+// Footer returns footer of the commit
+func (c *Commit) Footer() string {
+	return c.footer
+}
+
+// Type returns type of the commit
+func (c *Commit) Type() string {
+	return c.commitType
+}
+
+// Scope returns scope of the commit
+func (c *Commit) Scope() string {
+	return c.scope
+}
+
+// Description returns description of the commit
+func (c *Commit) Description() string {
+	return c.description
+}
+
+// Notes returns footer notes of the commit
+func (c *Commit) Notes() []Note {
+	return c.notes
+}
+
+// IsBreakingChange returns true if breaking change
+func (c *Commit) IsBreakingChange() bool {
+	return c.isBreakingChange
+}
+
+// Note represents one footer note
+type Note struct {
+	token string
+	value string
+}
 
-	FullFooter string
+func newNote(token, value string) Note {
+	return Note{
+		token: token,
+		value: value,
+	}
 }
 
-// FooterNote represents one footer note in Footer
-type FooterNote struct {
-	Token string
-	Value string
+func (n *Note) Token() string {
+	return n.token
 }
 
-func newFooterNote(token, value string) FooterNote {
-	return FooterNote{Token: token, Value: value}
+func (n *Note) Value() string {
+	return n.value
 }

errors.go

@@ -0,0 +1,18 @@
+package parser
+
+import "errors"
+
+var (
+	errHeader      = errors.New("unable to parse commit header")
+	errNoBlankLine = errors.New("commit description not followed by an empty line")
+)
+
+// IsHeaderErr checks if given error is header parse error
+func IsHeaderErr(err error) bool {
+	return errors.Is(err, errHeader)
+}
+
+// IsNoBlankLineErr checks if given error is no new line error
+func IsNoBlankLineErr(err error) bool {
+	return errors.Is(err, errNoBlankLine)
+}

example_test.go

@@ -23,5 +23,5 @@ By: John Doe`
 	}
 	fmt.Printf("%#v", commit)
 
-	// Output: &parser.Commit{Header:parser.Header{Type:"feat", Scope:"scope", Description:"description", FullHeader:"feat(scope): description"}, Body:"this is first line in body\n\nthis is second line in body", Footer:parser.Footer{Notes:[]parser.FooterNote{parser.FooterNote{Token:"Ref", Value:"123"}, parser.FooterNote{Token:"Date", Value:"01-01-2021"}, parser.FooterNote{Token:"By", Value:"John Doe"}}, FullFooter:"Ref #123\nDate: 01-01-2021\nBy: John Doe"}, BreakingChange:false, FullCommit:"feat(scope): description\n\nthis is first line in body\n\nthis is second line in body\n\nRef #123\nDate: 01-01-2021\nBy: John Doe"}
+	// Output: &parser.Commit{message:"feat(scope): description\n\nthis is first line in body\n\nthis is second line in body\n\nRef #123\nDate: 01-01-2021\nBy: John Doe", header:"feat(scope): description", body:"this is first line in body\n\nthis is second line in body", footer:"Ref #123\nDate: 01-01-2021\nBy: John Doe", commitType:"feat", scope:"scope", description:"description", notes:[]parser.Note{parser.Note{token:"Ref", value:"123"}, parser.Note{token:"Date", value:"01-01-2021"}, parser.Note{token:"By", value:"John Doe"}}, isBreakingChange:false}
 }

parser.go

@@ -2,7 +2,6 @@
 package parser
 
 import (
-	"errors"
 	"regexp"
 	"strings"
 )
@@ -19,39 +18,46 @@ const (
 	footRegExStr = `^(?:(BREAKING[- ]CHANGE|(?:[A-Za-z-])+): |((?:[A-Za-z-])+) #)(.+)$`
 )
 
-var (
-	headerRegexp = regexp.MustCompile(headRegExStr)
-	footerRegexp = regexp.MustCompile(footRegExStr)
-)
-
-var (
-	errHeader      = errors.New("unable to parse commit header")
-	errNoBlankLine = errors.New("commit description not followed by an empty line")
-)
+var defParser = newParser()
 
 // Parse attempts to parse a commit message to a conventional commit
 func Parse(message string) (*Commit, error) {
+	return defParser.parse(message)
+}
+
+type parser struct {
+	headerRegex, footerRegex *regexp.Regexp
+}
+
+func newParser() *parser {
+	headerRegex := regexp.MustCompile(headRegExStr)
+	footerRegex := regexp.MustCompile(footRegExStr)
+
+	return &parser{
+		headerRegex: headerRegex,
+		footerRegex: footerRegex,
+	}
+}
+
+func (p *parser) parse(message string) (*Commit, error) {
+	c := &Commit{
+		message: message,
+	}
+
 	message = strings.TrimRight(message, "\n\t ")
 	messageLines := strings.Split(message, "\n")
 
-	commit := &Commit{
-		FullCommit: message,
-	}
 	currKeyValue := ""
 	currFooterValue := ""
 
-	foot := Footer{}
-
 	inFooters := false
 	for i, msgLine := range messageLines {
 		// First Line
 		if i == 0 {
-			head, isBreak, err := parseHeader(msgLine)
+			err := p.parseHeader(c, msgLine)
 			if err != nil {
 				return nil, err
 			}
-			commit.Header = head
-			commit.BreakingChange = isBreak
 			continue
 		}
 
@@ -64,60 +70,62 @@ func Parse(message string) (*Commit, error) {
 		}
 
 		// Remaining Line
-		key, value, isFooter := parseLineAsFooter(msgLine)
+		key, value, isFooter := p.parseLineAsFooter(msgLine)
+		// Is Footer
 		if isFooter {
 			inFooters = true
 
 			// Check if we have previously found a footer. If we have, set the current footer,
 			// otherwise just record it.
 			if currKeyValue != "" {
-				foot.Notes = append(foot.Notes, newFooterNote(currKeyValue, currFooterValue))
-				foot.FullFooter += messageLines[i-1] + "\n" // add previous line to FullFooter
+				c.notes = append(c.notes, newNote(currKeyValue, currFooterValue))
+				c.footer += messageLines[i-1] + "\n" // add previous line to FullFooter
 			}
 
 			currKeyValue = key
 			currFooterValue = value
+			continue
+		}
+
+		// Not a Footer Line
+		if inFooters {
+			currFooterValue = currFooterValue + "\n" + msgLine
 		} else {
-			if inFooters {
-				currFooterValue = currFooterValue + "\n" + msgLine
+			if c.body == "" {
+				c.body = msgLine
 			} else {
-				if commit.Body == "" {
-					commit.Body = msgLine
-				} else {
-					commit.Body += "\n" + msgLine
-				}
+				c.body += "\n" + msgLine
 			}
 		}
 	}
 
 	// We reached the end of the commit message, so check if we need to record the footers
 	if inFooters {
-		foot.Notes = append(foot.Notes, newFooterNote(currKeyValue, currFooterValue))
-		foot.FullFooter += messageLines[len(messageLines)-1]
+		c.notes = append(c.notes, newNote(currKeyValue, currFooterValue))
+		c.footer += messageLines[len(messageLines)-1]
 	}
 
 	// Remove whitespace in the Full Footer
-	foot.FullFooter = strings.TrimSpace(foot.FullFooter)
+	c.footer = strings.TrimSpace(c.footer)
 
 	// Remove whitespace in the commit body
-	commit.Body = strings.TrimSpace(commit.Body)
-	commit.Footer = foot
+	c.body = strings.TrimSpace(c.body)
 
 	// Check if a footer contains a breaking change
-	for _, footer := range commit.Footer.Notes {
-		if footer.Token == "BREAKING CHANGE" || footer.Token == "BREAKING-CHANGE" {
-			commit.BreakingChange = true
+	for _, note := range c.notes {
+		if note.Token() == "BREAKING CHANGE" || note.Token() == "BREAKING-CHANGE" {
+			c.isBreakingChange = true
 			break
 		}
 	}
 
-	return commit, nil
+	return c, nil
 }
 
 // parseLineAsFooter attempts to parse the given line as a footer, returning both the key and the value of the header.
 // If the line cannot be parsed then isFooter is false
-func parseLineAsFooter(line string) (key, value string, isFooter bool) {
-	matches := footerRegexp.FindStringSubmatch(line)
+func (p *parser) parseLineAsFooter(line string) (key, value string, isFooter bool) {
+	matches := p.footerRegex.FindStringSubmatch(line)
 	if len(matches) != 4 {
 		return "", "", false
 	}
@@ -129,42 +137,28 @@ func parseLineAsFooter(line string) (key, value string, isFooter bool) {
 }
 
 // parseHeader attempts to parse the commit description line and set the appropriate values in the the given commit
-func parseHeader(header string) (Header, bool, error) {
-	matches := headerRegexp.FindStringSubmatch(header)
+func (p *parser) parseHeader(c *Commit, header string) error {
+	matches := p.headerRegex.FindStringSubmatch(header)
 	if matches == nil {
-		return Header{}, false, errHeader
+		return errHeader
 	}
 
-	head := Header{
-		FullHeader: header,
-	}
-
-	isBreakingChange := false
+	c.header = header
 
-	names := headerRegexp.SubexpNames()
+	names := p.headerRegex.SubexpNames()
 	for i, match := range matches {
 		switch names[i] {
 		case "type":
-			head.Type = match
+			c.commitType = match
 		case "scope":
 			// TODO: comma separated multiple scopes?
-			head.Scope = match
+			c.scope = match
 		case "description":
-			head.Description = match
+			c.description = match
 		case "breaking":
-			isBreakingChange = (match == "!")
+			c.isBreakingChange = (match == "!")
 		}
 	}
 
-	return head, isBreakingChange, nil
-}
-
-// IsHeaderErr checks if given error is header parse error
-func IsHeaderErr(err error) bool {
-	return errors.Is(err, errHeader)
-}
-
-// IsNoBlankLineErr checks if given error is no new line error
-func IsNoBlankLineErr(err error) bool {
-	return errors.Is(err, errNoBlankLine)
+	return nil
 }

parser_header_test.go

@@ -19,12 +19,15 @@ func TestParseHeaderValid(t *testing.T) {
 		"1245#feat1234(@scope/scope1,scope2): description, \n\n body 1 2, 3 and 4?",
 	}
 
+	p := newParser()
+
 	for index, validCase := range validCases {
 
 		testName := "case#" + strconv.Itoa(index+1)
 		t.Run(testName, func(innerT *testing.T) {
 			headerLine := strings.Split(validCase, "\n")[0]
-			_, _, err := parseHeader(headerLine)
+			c := &Commit{}
+			err := p.parseHeader(c, headerLine)
 			if err != nil {
 				innerT.Error("parseHeader failed for", headerLine, err)
 				return
@@ -47,11 +50,14 @@ func TestParseHeaderInvalid(t *testing.T) {
 		`feat(scope))!: A description with name.txt`,
 	}
 
+	p := newParser()
+
 	for index, validCase := range validCases {
 		testName := "case#" + strconv.Itoa(index+1)
 		t.Run(testName, func(innerT *testing.T) {
 			headerLine := strings.Split(validCase, "\n")[0]
-			_, _, err := parseHeader(headerLine)
+			c := &Commit{}
+			err := p.parseHeader(c, headerLine)
 			if err == nil {
 				innerT.Error("parseHeader passed without error for", headerLine)
 			}