Allow serving custom RuleSet by plugins

Author: wata727

plugin/client.go

@@ -60,7 +60,7 @@ func (c *Client) RuleNames() ([]string, error) {
 }
 
 // ApplyConfig calls the server-side ApplyConfig method.
-func (c *Client) ApplyConfig(config *tflint.Config) error {
+func (c *Client) ApplyConfig(config *tflint.MarshalledConfig) error {
 	return c.rpcClient.Call("Plugin.ApplyConfig", config, new(interface{}))
 }
 

plugin/server.go

@@ -47,9 +47,12 @@ func (s *Server) RuleNames(args interface{}, resp *[]string) error {
 }
 
 // ApplyConfig applies the passed config to its own plugin implementation.
-func (s *Server) ApplyConfig(config *tflint.Config, resp *interface{}) error {
-	s.impl.ApplyConfig(config)
-	return nil
+func (s *Server) ApplyConfig(config *tflint.MarshalledConfig, resp *interface{}) error {
+	cfg, err := config.Unmarshal()
+	if err != nil {
+		return err
+	}
+	return s.impl.ApplyConfig(cfg)
 }
 
 // Check calls its own plugin implementation with an RPC client that can send

tflint/config.go

@@ -1,14 +1,42 @@
 package tflint
 
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
 // Config is a TFLint configuration applied to the plugin.
-// Currently, it is not expected that each plugin will reference this directly.
+// The Body contains the contents declared in the "plugin" block.
 type Config struct {
 	Rules             map[string]*RuleConfig
 	DisabledByDefault bool
+	Body              hcl.Body
 }
 
 // RuleConfig is a TFLint's rule configuration.
 type RuleConfig struct {
 	Name    string
 	Enabled bool
 }
+
+// MarshalledConfig is an intermediate representation of Config for communicating over RPC
+type MarshalledConfig struct {
+	Rules             map[string]*RuleConfig
+	DisabledByDefault bool
+	BodyBytes         []byte
+	BodyRange         hcl.Range
+}
+
+// Unmarshal converts intermediate representations into the Config object.
+func (c *MarshalledConfig) Unmarshal() (*Config, error) {
+	file, diags := hclsyntax.ParseConfig(c.BodyBytes, c.BodyRange.Filename, c.BodyRange.Start)
+	if diags.HasErrors() {
+		return nil, diags
+	}
+
+	return &Config{
+		Rules:             c.Rules,
+		DisabledByDefault: c.DisabledByDefault,
+		Body:              file.Body,
+	}, nil
+}

tflint/interface.go

@@ -5,6 +5,29 @@ import (
 	"github.com/terraform-linters/tflint-plugin-sdk/terraform/configs"
 )
 
+// RuleSet is a list of rules that a plugin should provide.
+// Normally, plugins can use BuiltinRuleSet directly,
+// but you can also use custom rulesets that satisfy this interface.
+type RuleSet interface {
+	// RuleSetName is the name of the ruleset. This method is not expected to be overridden.
+	RuleSetName() string
+
+	// RuleSetVersion is the version of the plugin. This method is not expected to be overridden.
+	RuleSetVersion() string
+
+	// RuleNames is a list of rule names provided by the plugin. This method is not expected to be overridden.
+	RuleNames() []string
+
+	// ApplyConfig reflects the configuration to the ruleset.
+	// Custom rulesets can override this method to reflect the plugin's own configuration.
+	// In that case, don't forget to call ApplyCommonConfig.
+	ApplyConfig(*Config) error
+
+	// Check runs inspection for each rule by applying Runner.
+	// This is a entrypoint for all inspections and can be used as a hook to inject a custom runner.
+	Check(Runner) error
+}
+
 // Runner acts as a client for each plugin to query the host process about the Terraform configurations.
 type Runner interface {
 	// WalkResourceAttributes visits attributes with the passed function.

tflint/ruleset.go

@@ -5,36 +5,43 @@ import (
 	"log"
 )
 
-// RuleSet is a list of rules that a plugin should provide.
-type RuleSet struct {
+// BuiltinRuleSet is the basis of the ruleset. Plugins can serve this ruleset directly.
+// You can serve a custom ruleset by embedding this ruleset if you need special extensions.
+type BuiltinRuleSet struct {
 	Name    string
 	Version string
 	Rules   []Rule
 }
 
 // RuleSetName is the name of the ruleset.
 // Generally, this is synonymous with the name of the plugin.
-func (r *RuleSet) RuleSetName() string {
+func (r *BuiltinRuleSet) RuleSetName() string {
 	return r.Name
 }
 
 // RuleSetVersion is the version of the plugin.
-func (r *RuleSet) RuleSetVersion() string {
+func (r *BuiltinRuleSet) RuleSetVersion() string {
 	return r.Version
 }
 
 // RuleNames is a list of rule names provided by the plugin.
-func (r *RuleSet) RuleNames() []string {
+func (r *BuiltinRuleSet) RuleNames() []string {
 	names := []string{}
 	for _, rule := range r.Rules {
 		names = append(names, rule.Name())
 	}
 	return names
 }
 
-// ApplyConfig reflects the plugin configuration in the ruleset.
-// Currently used only to enable/disable rules.
-func (r *RuleSet) ApplyConfig(config *Config) {
+// ApplyConfig reflects the configuration to the ruleset.
+// By default, this only applies common configurations.
+func (r *BuiltinRuleSet) ApplyConfig(config *Config) error {
+	r.ApplyCommonConfig(config)
+	return nil
+}
+
+// ApplyCommonConfig reflects common configurations regardless of plugins.
+func (r *BuiltinRuleSet) ApplyCommonConfig(config *Config) {
 	rules := []Rule{}
 
 	if config.DisabledByDefault {
@@ -57,7 +64,7 @@ func (r *RuleSet) ApplyConfig(config *Config) {
 }
 
 // Check runs inspection for each rule by applying Runner.
-func (r *RuleSet) Check(runner Runner) error {
+func (r *BuiltinRuleSet) Check(runner Runner) error {
 	for _, rule := range r.Rules {
 		if err := rule.Check(runner); err != nil {
 			return fmt.Errorf("Failed to check `%s` rule: %s", rule.Name(), err)