Add new configuration option for puppet classes

lib/kafo/configuration.rb

@@ -43,6 +43,7 @@ class Configuration
       ScenarioOption::KAFO_MODULES_DIR          => nil,
       ScenarioOption::CONFIG_HEADER_FILE        => nil,
       ScenarioOption::DONT_SAVE_ANSWERS         => nil,
+      ScenarioOption::CLASSES                   => {},
     }
 
     def self.get_scenario_id(filename)
@@ -130,7 +131,27 @@ def has_custom_fact?(key)
     def modules
       @modules ||= begin
         register_data_types
-        @data.keys.map { |mod| PuppetModule.new(mod, configuration: self).parse }.sort
+
+        @data.map do |name, values|
+          if (class_config = app[:classes][name.to_sym])
+            can_disable = class_config[:can_disable] || false
+            excluded_params = class_config[:exclude] || []
+          else
+            can_disable = true
+            excluded_params = []
+          end
+
+          enabled = !!values || values.is_a?(Hash)
+
+          puppet_mod = PuppetModule.new(
+            name,
+            configuration: self,
+            enabled: enabled,
+            can_disable: can_disable,
+            excluded_params: excluded_params
+          )
+          puppet_mod.parse
+        end.sort
       end
     end
 
@@ -159,7 +180,7 @@ def kafo_modules_dir
     end
 
     def add_module(name)
-      mod = PuppetModule.new(name, configuration: self).parse
+      mod = PuppetModule.new(name, configuration: self, enabled: false).parse
       unless modules.map(&:name).include?(mod.name)
         mod.enable
         @modules << mod
@@ -236,11 +257,6 @@ def [](key)
       value.is_a?(Hash) ? value : {}
     end
 
-    def module_enabled?(mod)
-      value = @data[mod.is_a?(String) ? mod : mod.identifier]
-      !!value || value.is_a?(Hash)
-    end
-
     def config_header
       files          = [app[:config_header_file], File.join(gem_root, '/config/config_header.txt')].compact
       file           = files.find { |f| File.exist?(f) }
@@ -295,7 +311,7 @@ def params_changed(old_config)
     def params_missing(old_config)
       # finds params that are present but will be missing in the new config
       old_config.params.select do |par|
-        next if !par.module.enabled? || !module_enabled?(par.module.name)
+        next if !par.module.enabled?
         param(par.module.class_name, par.name).nil?
       end
     end

lib/kafo/kafo_configure.rb

@@ -388,11 +388,15 @@ def set_options
       end
 
       modules.each do |mod|
-        app_option d("--[no-]enable-#{mod.name}"), :flag, "Enable '#{mod.name}' puppet module",
-                   :default => mod.enabled?
+        if mod.can_disable?
+          app_option d("--[no-]enable-#{mod.name}"), :flag, "Enable '#{mod.name}' puppet module (current: #{mod.enabled?})", :default => mod.enabled?
+        elsif !mod.enabled?
+          app_option d("--enable-#{mod.name}"), :flag, "Enable '#{mod.name}' puppet module (current: #{mod.enabled?})"
+        end
       end
 
       params.sort.each do |param|
+        next if param.module.excluded_param?(dashize(param.name))
         doc = param.doc.nil? ? 'UNDOCUMENTED' : param.doc.join("\n")
         app_option parametrize(param), '', doc + " (current: #{param.value_to_s})",
                    :multivalued => param.multivalued?

lib/kafo/puppet_module.rb

@@ -25,7 +25,7 @@ def self.find_parser
       end
     end
 
-    def initialize(identifier, parser: nil, configuration: KafoConfigure.config)
+    def initialize(identifier, parser: nil, configuration: KafoConfigure.config, enabled: nil, can_disable: true, excluded_params: [])
       @identifier        = identifier
       @configuration     = configuration
       @name              = get_name
@@ -47,14 +47,21 @@ def initialize(identifier, parser: nil, configuration: KafoConfigure.config)
       @params_path       = get_params_path
       @params_class_name = get_params_class_name
       @raw_data          = nil
-      @enabled           = nil
+      @enabled           = enabled
+      @can_disable       = can_disable
+      @excluded_params   = excluded_params
     end
 
     def enabled?
-      @enabled.nil? ? @enabled = @configuration.module_enabled?(self) : @enabled
+      @enabled
+    end
+
+    def can_disable?
+      @can_disable
     end
 
     def disable
+      return unless can_disable?
       @enabled = false
     end
 
@@ -97,6 +104,10 @@ def params_hash
       Hash[params.map { |param| [param.name, param.value] }]
     end
 
+    def excluded_param?(param)
+      @excluded_params.include?(param)
+    end
+
     def <=>(other)
       @configuration.app[:low_priority_modules].each do |module_name|
         return 1 if self.name.include?(module_name) && !other.name.include?(module_name)

lib/kafo/scenario_option.rb

@@ -88,5 +88,7 @@ class ScenarioOption
     # implements checks to verify this is correct with the Puppet version
     # that's running. This can be used to bypass the checks
     SKIP_PUPPET_VERSION_CHECK = :skip_puppet_version_check
+
+    CLASSES = :classes
   end
 end

test/acceptance/kafo_configure_test.rb

@@ -340,5 +340,54 @@ module Kafo
         _(stdout).must_include "Hello Kafo\nGoodbye"
       end
     end
+
+    describe 'with classes' do
+      it 'includes enable flag by default' do
+        code, out, err = run_command '../bin/kafo-configure --help'
+        _(code).must_equal 0, err
+        _(out).must_include "--[no-]enable-testing"
+      end
+
+      it 'does not show disable flag if class cannot be disabled' do
+        config = YAML.load_file(KAFO_CONFIG)
+        config[:classes] = {:testing => {:can_disable => false}}
+        File.open(KAFO_CONFIG, 'w') do |file|
+          file.write(config.to_yaml)
+        end
+
+        code, out, err = run_command '../bin/kafo-configure --help'
+        _(code).must_equal 0, err
+        _(out).wont_include "--[no-]enable-testing"
+      end
+
+      it 'shows enable flag if class is disabled' do
+        config = YAML.load_file(KAFO_CONFIG)
+        config[:classes] = {:testing => {:can_disable => false}}
+        File.open(KAFO_CONFIG, 'w') do |file|
+          file.write(config.to_yaml)
+        end
+
+        answers = {'testing' => false}
+        File.open(KAFO_ANSWERS, 'w') do |file|
+          file.write(answers.to_yaml)
+        end
+
+        code, out, err = run_command '../bin/kafo-configure --help'
+        _(code).must_equal 0, err
+        _(out).must_include "--enable-testing"
+      end
+
+      it 'allows declaring parameters that should be excluded as command line options' do
+        config = YAML.load_file(KAFO_CONFIG)
+        config[:classes] = {:testing => {:exclude => ['version']}}
+        File.open(KAFO_CONFIG, 'w') do |file|
+          file.write(config.to_yaml)
+        end
+
+        code, out, err = run_command '../bin/kafo-configure --full-help'
+        _(code).must_equal 0, err
+        _(out).wont_include "--testing-version"
+      end
+    end
   end
 end

test/kafo/configuration_test.rb

@@ -76,10 +76,8 @@ module Kafo
     describe '#params_missing' do
       it 'lists all the params that are missing in the new config' do
         basic_config.stub(:modules, [fake_module('mod', [p_foo, p_bar])]) do
-          basic_config.stub(:module_enabled?, true) do
-            old_config.stub(:modules, [fake_module('mod', [p_old_foo, p_old_baz])]) do
-              _(basic_config.params_missing(old_config)).must_equal([p_old_baz])
-            end
+          old_config.stub(:modules, [fake_module('mod', [p_old_foo, p_old_baz])]) do
+            _(basic_config.params_missing(old_config)).must_equal([p_old_baz])
           end
         end
       end

test/kafo/puppet_module_test.rb

@@ -7,7 +7,7 @@ module Kafo
     end
 
     let(:parser) { TestParser.new(BASIC_MANIFEST) }
-    let(:mod) { PuppetModule.new 'puppet', parser: parser }
+    let(:mod) { PuppetModule.new 'puppet', parser: parser, enabled: true }
 
     describe "#enabled?" do
       specify { _(mod.enabled?).must_equal true }

test/kafo/scenario_manager_test.rb

@@ -330,10 +330,8 @@ def create_and_load_scenarios(content, filename='default.yaml')
       it 'prints values that will be lost' do
         old_config.stub(:modules, [fake_module('mod', [p_old_baz])]) do
           new_config.stub(:modules, []) do
-            new_config.stub(:module_enabled?, true) do
-              manager.print_scenario_diff(old_config, new_config)
-              must_be_on_stdout(output, "mod::baz: 100\n")
-            end
+            manager.print_scenario_diff(old_config, new_config)
+            must_be_on_stdout(output, "mod::baz: 100\n")
           end
         end
       end

test/kafo/wizard_test.rb

@@ -11,7 +11,7 @@ module Kafo
     let(:output) { StringIO.new }
 
     let(:parser) { @@puppet_parser ||= TestParser.new(BASIC_MANIFEST) }
-    let(:puppet_module) { PuppetModule.new('puppet', parser: parser).parse }
+    let(:puppet_module) { PuppetModule.new('puppet', parser: parser, enabled: true).parse }
 
     let(:kafo) do
       kafo                     = OpenStruct.new