config.go

package model

import (
	"regexp"
	"strings"

	"github.com/BurntSushi/toml"
	"github.com/ianschenck/envflag"
)

// Config represents a repo-specific configuration file.
type Config struct {
	Approvals             int      `json:"approvals"         toml:"approvals"`
	Pattern               string   `json:"pattern"           toml:"pattern"`
	Teams                 []string `json:"team"              toml:"teams"`
	SelfApprovalOff       bool     `json:"self_approval_off" toml:"self_approval_off"`
	IgnoreMaintainersFile bool     `json:"ignore_maintainers_file" toml:"ignore_maintainers_file"`
	// deprecated
	Team string `json:"team"              toml:"team"`

	re *regexp.Regexp
}

var (
	approvals             = envflag.Int("LGTM_APPROVALS", 2, "")
	pattern               = envflag.String("LGTM_PATTERN", "(?i)LGTM", "")
	teams                 = envflag.String("LGTM_TEAMS", "MAINTAINERS", "")
	selfApprovalOff       = envflag.Bool("LGTM_SELF_APPROVAL_OFF", false, "")
	ignoreMaintainersFile = envflag.Bool("IGNORE_MAINTAINERS_FILE", false, "")

	// deprecated
	team = envflag.String("LGTM_TEAM", "", "")
)

// ParseConfig parses a projects .lgtm file
func ParseConfig(data []byte) (*Config, error) {
	return ParseConfigStr(string(data))
}

// ParseConfigStr parses a projects .lgtm file in string format.
func ParseConfigStr(data string) (*Config, error) {
	c := new(Config)
	_, err := toml.Decode(data, c)
	if err != nil {
		return nil, err
	}
	if c.Approvals == 0 {
		c.Approvals = *approvals
	}
	if len(c.Pattern) == 0 {
		c.Pattern = *pattern
	}
	if len(c.Team) == 0 {
		c.Team = *team
	}
	if len(c.Teams) == 0 {
		if len(*teams) != 0 {
			for _, t := range strings.Split(*teams, ",") {
				c.Teams = append(c.Teams, strings.TrimSpace(t))
			}
		} else {
			c.Teams = []string{c.Team}
		}
	}
	if c.SelfApprovalOff == false {
		c.SelfApprovalOff = *selfApprovalOff
	}
	if c.IgnoreMaintainersFile == false {
		c.IgnoreMaintainersFile = *ignoreMaintainersFile
	}

	c.re, err = regexp.Compile(c.Pattern)
	return c, err
}

// IsMatch returns true if the text matches the regular
// epxression pattern.
func (c *Config) IsMatch(text string) bool {
	if c.re == nil {
		// this should never happen
		return false
	}
	return c.re.MatchString(text)
}