remove filenames from Linter interface, pass to constructor for linte…

…rs that use files

cli/app.go

@@ -99,12 +99,12 @@ func main() {
 			fmt.Println("Unable to parse rules in:" + rulesFilename)
 			fmt.Println(err.Error())
 		}
-		linter := makeLinter(ruleSet.Type, assertion.MakeLogger(*verboseLogging))
+		linter := makeLinter(ruleSet.Type, flag.Args(), assertion.MakeLogger(*verboseLogging))
 		if linter != nil {
 			if *searchExpression != "" {
-				linter.Search(flag.Args(), ruleSet, *searchExpression)
+				linter.Search(ruleSet, *searchExpression)
 			} else {
-				r, err := linter.Validate(flag.Args(), ruleSet, makeTagList(*tags), makeRulesList(*ids))
+				r, err := linter.Validate(ruleSet, makeTagList(*tags), makeRulesList(*ids))
 				if err != nil {
 					fmt.Println("Validate failed:", err) // FIXME
 				}

cli/aws_resource_linter.go

@@ -19,7 +19,7 @@ type (
 )
 
 // Validate applies a Ruleset to all SecurityGroups
-func (l AWSResourceLinter) Validate(filenames []string, ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
+func (l AWSResourceLinter) Validate(ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
 	rules := assertion.FilterRulesByTagAndID(ruleSet.Rules, tags, ruleIDs)
 	resources, err := l.Loader.Load()
 	if err != nil {
@@ -30,7 +30,7 @@ func (l AWSResourceLinter) Validate(filenames []string, ruleSet assertion.RuleSe
 }
 
 // Search applies a JMESPath to all SecurityGroups
-func (l AWSResourceLinter) Search(filenames []string, ruleSet assertion.RuleSet, searchExpression string) {
+func (l AWSResourceLinter) Search(ruleSet assertion.RuleSet, searchExpression string) {
 	resources, _ := l.Loader.Load()
 	for _, resource := range resources {
 		v, err := assertion.SearchData(searchExpression, resource.Properties)

cli/file_linter.go

@@ -7,11 +7,12 @@ import (
 
 // FileLinter provides implementation for some common functions that are used by multiple Linter implementations
 type FileLinter struct {
-	Log assertion.LoggingFunction
+	Filenames []string
+	Log       assertion.LoggingFunction
 }
 
 // ValidateFiles validates a collection of filenames using a RuleSet
-func (l FileLinter) ValidateFiles(filenames []string, ruleSet assertion.RuleSet, tags []string, ruleIDs []string, loader ResourceLoader) (assertion.ValidationReport, error) {
+func (l FileLinter) ValidateFiles(ruleSet assertion.RuleSet, tags []string, ruleIDs []string, loader ResourceLoader) (assertion.ValidationReport, error) {
 
 	report := assertion.ValidationReport{
 		FilesScanned:     []string{},
@@ -20,7 +21,7 @@ func (l FileLinter) ValidateFiles(filenames []string, ruleSet assertion.RuleSet,
 	}
 	rules := assertion.FilterRulesByTagAndID(ruleSet.Rules, tags, ruleIDs)
 	r := ResourceLinter{Log: l.Log}
-	for _, filename := range filenames {
+	for _, filename := range l.Filenames {
 		include, err := assertion.ShouldIncludeFile(ruleSet.Files, filename)
 		if err == nil && include {
 			l.Log(fmt.Sprintf("Processing %s", filename))
@@ -40,8 +41,8 @@ func (l FileLinter) ValidateFiles(filenames []string, ruleSet assertion.RuleSet,
 }
 
 // SearchFiles evaluates a JMESPath expression against resources in a collection of filenames
-func (l FileLinter) SearchFiles(filenames []string, ruleSet assertion.RuleSet, searchExpression string, loader ResourceLoader) {
-	for _, filename := range filenames {
+func (l FileLinter) SearchFiles(ruleSet assertion.RuleSet, searchExpression string, loader ResourceLoader) {
+	for _, filename := range l.Filenames {
 		include, _ := assertion.ShouldIncludeFile(ruleSet.Files, filename) // FIXME what about error?
 		if include {
 			fmt.Printf("Searching %s:\n", filename)

cli/kubernetes.go

@@ -6,7 +6,8 @@ import (
 
 // KubernetesLinter lints resources in Kubernets YAML files
 type KubernetesLinter struct {
-	Log assertion.LoggingFunction
+	Filenames []string
+	Log       assertion.LoggingFunction
 }
 
 // KubernetesResourceLoader converts Kubernetes configuration files into a collection of Resource objects
@@ -50,15 +51,15 @@ func (l KubernetesResourceLoader) Load(filename string) ([]assertion.Resource, e
 }
 
 // Validate runs validate on a collection of filenames using a RuleSet
-func (l KubernetesLinter) Validate(filenames []string, ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
+func (l KubernetesLinter) Validate(ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
 	loader := KubernetesResourceLoader{Log: l.Log}
-	f := FileLinter{Log: l.Log}
-	return f.ValidateFiles(filenames, ruleSet, tags, ruleIDs, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	return f.ValidateFiles(ruleSet, tags, ruleIDs, loader)
 }
 
 // Search evaluates a JMESPath expression against the resources in a collection of filenames
-func (l KubernetesLinter) Search(filenames []string, ruleSet assertion.RuleSet, searchExpression string) {
+func (l KubernetesLinter) Search(ruleSet assertion.RuleSet, searchExpression string) {
 	loader := KubernetesResourceLoader{Log: l.Log}
-	f := FileLinter{Log: l.Log}
-	f.SearchFiles(filenames, ruleSet, searchExpression, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	f.SearchFiles(ruleSet, searchExpression, loader)
 }

cli/linter.go

@@ -9,29 +9,29 @@ import (
 
 // Linter provides the interface for all supported linters
 type Linter interface {
-	Validate(filenames []string, ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error)
-	Search(filenames []string, ruleSet assertion.RuleSet, searchExpression string)
+	Validate(ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error)
+	Search(ruleSet assertion.RuleSet, searchExpression string)
 }
 
 // ResourceLoader provides the interface that a Linter needs to load a collection of Resource objects
 type ResourceLoader interface {
 	Load(filename string) ([]assertion.Resource, error)
 }
 
-func makeLinter(linterType string, log assertion.LoggingFunction) Linter {
+func makeLinter(linterType string, args []string, log assertion.LoggingFunction) Linter {
 	switch linterType {
 	case "Kubernetes":
-		return KubernetesLinter{Log: log}
+		return KubernetesLinter{Filenames: args, Log: log}
 	case "Terraform":
-		return TerraformLinter{Log: log}
+		return TerraformLinter{Filenames: args, Log: log}
 	case "SecurityGroup":
 		return AWSResourceLinter{Loader: SecurityGroupLoader{}, Log: log}
 	case "IAMUser":
 		return AWSResourceLinter{Loader: IAMUserLoader{}, Log: log}
 	case "LintRules":
-		return RulesLinter{Log: log}
+		return RulesLinter{Filenames: args, Log: log}
 	case "YAML":
-		return YAMLLinter{Log: log}
+		return YAMLLinter{Filenames: args, Log: log}
 	default:
 		fmt.Printf("Type not supported: %s\n", linterType)
 		return nil

cli/rules_linter.go

@@ -6,7 +6,8 @@ import (
 
 // RulesLinter lints rules files for itself
 type RulesLinter struct {
-	Log assertion.LoggingFunction
+	Filenames []string
+	Log       assertion.LoggingFunction
 }
 
 // RulesResourceLoader converts a YAML configuration file into a collection with Resource objects
@@ -58,15 +59,15 @@ func (l RulesResourceLoader) Load(filename string) ([]assertion.Resource, error)
 }
 
 // Validate runs validate on a collection of filenames using a RuleSet
-func (l RulesLinter) Validate(filenames []string, ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
+func (l RulesLinter) Validate(ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
 	loader := RulesResourceLoader{Log: l.Log}
-	f := FileLinter{Log: l.Log}
-	return f.ValidateFiles(filenames, ruleSet, tags, ruleIDs, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	return f.ValidateFiles(ruleSet, tags, ruleIDs, loader)
 }
 
 // Search evaluates a JMESPath expression against the resources in a collection of filenames
-func (l RulesLinter) Search(filenames []string, ruleSet assertion.RuleSet, searchExpression string) {
+func (l RulesLinter) Search(ruleSet assertion.RuleSet, searchExpression string) {
 	loader := RulesResourceLoader{Log: l.Log}
-	f := FileLinter{Log: l.Log}
-	f.SearchFiles(filenames, ruleSet, searchExpression, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	f.SearchFiles(ruleSet, searchExpression, loader)
 }

cli/terraform.go

@@ -11,7 +11,8 @@ import (
 
 // TerraformLinter implements a Linter for Terraform configuration files
 type TerraformLinter struct {
-	Log assertion.LoggingFunction
+	Filenames []string
+	Log       assertion.LoggingFunction
 }
 
 // TerraformResourceLoader converts Terraform configuration files into JSON objects
@@ -102,15 +103,15 @@ func (l TerraformResourceLoader) Load(filename string) ([]assertion.Resource, er
 }
 
 // Validate uses a RuleSet to validate resources in a collection of Terraform configuration files
-func (l TerraformLinter) Validate(filenames []string, ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
+func (l TerraformLinter) Validate(ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
 	loader := TerraformResourceLoader{Log: l.Log}
-	f := FileLinter{Log: l.Log}
-	return f.ValidateFiles(filenames, ruleSet, tags, ruleIDs, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	return f.ValidateFiles(ruleSet, tags, ruleIDs, loader)
 }
 
 // Search applies a JMESPath expression to the resources in a collection of Terraform configuration files
-func (l TerraformLinter) Search(filenames []string, ruleSet assertion.RuleSet, searchExpression string) {
+func (l TerraformLinter) Search(ruleSet assertion.RuleSet, searchExpression string) {
 	loader := TerraformResourceLoader{Log: l.Log}
-	f := FileLinter{Log: l.Log}
-	f.SearchFiles(filenames, ruleSet, searchExpression, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	f.SearchFiles(ruleSet, searchExpression, loader)
 }

cli/terraform_test.go

@@ -7,10 +7,10 @@ import (
 func TestTerraformLinter(t *testing.T) {
 	emptyTags := []string{}
 	emptyIds := []string{}
-	linter := TerraformLinter{Log: testLogger}
-	ruleSet := loadRulesForTest("./testdata/rules/terraform_instance.yml", t)
 	filenames := []string{"./testdata/resources/terraform_instance.tf"}
-	report, err := linter.Validate(filenames, ruleSet, emptyTags, emptyIds)
+	linter := TerraformLinter{Filenames: filenames, Log: testLogger}
+	ruleSet := loadRulesForTest("./testdata/rules/terraform_instance.yml", t)
+	report, err := linter.Validate(ruleSet, emptyTags, emptyIds)
 	if err != nil {
 		t.Error("Expecting TestTerraformLinter to not return an error")
 	}

cli/yaml_linter.go

@@ -6,7 +6,8 @@ import (
 
 // YAMLLinter lints rules from a generic YAML file
 type YAMLLinter struct {
-	Log assertion.LoggingFunction
+	Filenames []string
+	Log       assertion.LoggingFunction
 }
 
 // YAMLResourceLoader loads a list of Resource objects based on the list of ResourceConfig objects
@@ -54,15 +55,15 @@ func (l YAMLResourceLoader) Load(filename string) ([]assertion.Resource, error)
 }
 
 // Validate runs validate on a collection of filenames using a RuleSet
-func (l YAMLLinter) Validate(filenames []string, ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
+func (l YAMLLinter) Validate(ruleSet assertion.RuleSet, tags []string, ruleIDs []string) (assertion.ValidationReport, error) {
 	loader := YAMLResourceLoader{Log: l.Log, Resources: ruleSet.Resources}
-	f := FileLinter{Log: l.Log}
-	return f.ValidateFiles(filenames, ruleSet, tags, ruleIDs, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	return f.ValidateFiles(ruleSet, tags, ruleIDs, loader)
 }
 
 // Search evaluates a JMESPath expression against the resources in a collection of filenames
-func (l YAMLLinter) Search(filenames []string, ruleSet assertion.RuleSet, searchExpression string) {
+func (l YAMLLinter) Search(ruleSet assertion.RuleSet, searchExpression string) {
 	loader := YAMLResourceLoader{Log: l.Log, Resources: ruleSet.Resources}
-	f := FileLinter{Log: l.Log}
-	f.SearchFiles(filenames, ruleSet, searchExpression, loader)
+	f := FileLinter{Filenames: l.Filenames, Log: l.Log}
+	f.SearchFiles(ruleSet, searchExpression, loader)
 }

cli/yaml_linter_test.go

@@ -7,10 +7,10 @@ import (
 func TestYAMLLinter(t *testing.T) {
 	emptyTags := []string{}
 	emptyIds := []string{}
-	linter := YAMLLinter{Log: testLogger}
-	ruleSet := loadRulesForTest("./testdata/rules/generic.yml", t)
 	filenames := []string{"./testdata/resources/generic.config"}
-	report, err := linter.Validate(filenames, ruleSet, emptyTags, emptyIds)
+	linter := YAMLLinter{Filenames: filenames, Log: testLogger}
+	ruleSet := loadRulesForTest("./testdata/rules/generic.yml", t)
+	report, err := linter.Validate(ruleSet, emptyTags, emptyIds)
 	if err != nil {
 		t.Error("Expecting TestYAMLLinter to not return an error")
 	}