kafo 0.3.17 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 426538f59aa0198c703fa2aef6172b06e3297bf9
-  data.tar.gz: ca884204fb99cac059c8aaa41d6a6f4baadcfa40
+  metadata.gz: cec1cec4f897c23ed85f473caca2b1e9fc7feea7
+  data.tar.gz: 5cd2bb6b161e2fdbf71e42425df0179cad53226b
 SHA512:
-  metadata.gz: 6d474f25575e38ceedbe7726450168bad1225737fe32d22a5c58ce15f39cef8d1bde03899e7f3a556b915defbfb5632094b800c25d27b9e06cf56a5e47ef2f55
-  data.tar.gz: d1e54d17cfb71fa7493ce77ea1aff6b5d544895daf8573141da6ea205ef6a5b339abc05ce1b703fcf830bc96e0cf0fcc9e785d12d522bc02c69fa13399407c98
+  metadata.gz: ad300f9ee839582ea0b81b26861f75347280f9ab746bcf7c70130141c430f7dcf5da98e62671912053c5bb4e0fe98b4feb8020af63468288dbee5681909643e7
+  data.tar.gz: 7ea593a6fda67a94dbb9daaa88ac9138086e974d7fec9c62737c76145445334e8ef783dae6ffab8a99f3253525e4f45bed55640a9b1a9e4d8c81aa5d6d79ae35

data/README.md

@@ -62,28 +62,51 @@ Now we run ```kafofy``` script which will prepare directory structure and
 optionally create a bin script according to first parameter.
 
 ```bash
-kafofy foreman-installer
+kafofy -n foreman-installer
 ```
 
 You can see that it created modules directory where your puppet modules
-should live. It also created config and bin directories. If you specified
-argument (foreman-installer in this case) a script in bin was created.
+should live. It also created config and bin directories. If you specify
+argument --name (or -n for short, foreman-installer in this case) a script in 
+bin is created.
+
 It's the script you can use to run installer. If you did not specify any
-you can run your installer by ```kafo-configure``` which is provided by the gem.
+you can run your installer by ```kafo-configure``` which is the default.
 All configuration related files are to be found in config directory.
 
+You can supply custom locations for you configuration and answers files using
+options:
+
+```kafofy --help
+Usage: kafofy [options]
+    -a, --answer_file FILE           location of the answer file
+    -c, --config_file FILE           location of the configuration file
+    -n, --name        NAME           your installer name
+```
+
+Configuration file will be created by default template. It's the configuration
+of you installer (so you can setup log level, path to puppet modules etc).
+On the other hand, answer file must be created manually. Answer file defines
+which modules should be used and hold all values for puppet class parameters.
+
+
 So for example to install foreman you want to
 ```bash
 cd foreman-installer/modules
 git clone https://github.com/theforeman/puppet-foreman/ foreman
 ```
-Currently you must also download any dependant modules.
+You must also download any dependant modules.
 Then you need to tell kafo it's going to use foreman module.
 ```bash
 cd ..
 echo "foreman: true" > config/answers.yaml
 ```
-Fire it with -h
+
+Alternatively you can use librarian-puppet project to manage all deps for you.
+You just create a Puppetfile and call librarian to install your modules. See
+https://github.com/rodjek/librarian-puppet for more details.
+
+When you have your modules in-place, fire the installer with -h argument
 ```bash
 bin/foreman-installer -h
 ```
@@ -501,6 +524,56 @@ You can register as many hooks as you need. They are executed in unspecified ord
 must have a unique name. In a very similar way you can register :post hooks that are executed
 right after puppet run is over.
 
+## Colors
+
+Everybody loves colors right? In case you don't you can disable them using ```--no-colors``` 
+argument or disallow them in installer config file (search for ```colors:``` key and set
+it to false). If you don't touch this setting, kafo will try to detect whether colors
+are supported and will enable/disable it accordingly.
+
+Kafo supports two sets of colors, one for terminals with bright and one for dark backround.
+You can specify your installer default scheme in installer config file (```color_of_background``` 
+key). Or user can override this default setting by ```--color-of-background``` argument.
+Possible values are ```dark``` and ```bright```.
+
+You can reuse kafo color schema in your custom hooks (so you can reuse dark/bright logic).
+Look at this example in bin/foreman-installer
+```ruby
+#!/usr/bin/env ruby
+
+# Run the install
+@result = Kafo::KafoConfigure.run
+exit 0 if @result.nil? # --help invocation
+
+# Puppet status codes say 0 for unchanged, 2 for changed succesfully
+if [0,2].include?(@result.exit_code)
+  say "  <%= color('Success!', :good) %>"
+
+  if module_enabled? 'foreman'
+    say "  * <%= color('Foreman', :info) %> is running at <%= color('#{get_param('foreman','foreman_url')}', :info) %>"
+    say "      Default credentials are '<%= color('admin:changeme', :info) %>'"e
+  end
+end
+```
+
+As you can see you can use HighLine helpers (e.g. say) with colors. Look at kafo/color_schema.rb for
+supported color identifiers. We can guarantee that there will always be at least :good, :bad, :info.
+
+Methods like module_enabled? and get_param are just helpers defined in the same file. If you find 
+them useful, here's the definition
+
+```ruby
+def module_enabled?(name)
+  mod = @result.module(name)
+  return false if mod.nil?
+  mod.enabled?
+end
+
+def get_param(mod, name)
+  @result.param(mod, name).value
+end
+```
+
 ## Custom paths
 
 Usually when you package your installer you want to load files from specific

data/bin/kafofy

@@ -1,6 +1,33 @@
 #!/usr/bin/env ruby
 
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
 require 'fileutils'
+require 'optparse'
+require 'yaml'
+require 'kafo/configuration'
+
+
+# Option Parsing
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: kafofy"
+  options[:answer_file] = './config/answers.yaml'
+  opts.on("-a", "--answer_file FILE", "location of the answer file") do |answer_file|
+    options[:answer_file] = answer_file
+  end
+  opts.on("-c", "--config_file FILE", "location of the configuration file") do |config_file|
+    options[:config_file] = config_file
+  end
+  opts.on("-n", "--name NAME", "installer name") do |name|
+    options[:name] = name
+  end
+end.parse!
+
+config = Kafo::Configuration::DEFAULT
+options[:answer_file] ||= config[:answer_file]
+options[:name] ||= "kafo-configure"
+options[:config_file] ||= "./config/#{options[:name]}.yaml"
 
 # Create directory structure
 %w(bin config modules).each do |dir|
@@ -13,27 +40,36 @@ src = File.expand_path(File.join(File.dirname(__FILE__), '..'))
   FileUtils.cp src + "/config/#{file}", 'config/'
 end
 
-script_name = "kafo-configure"
-# Optional configure script
-if ARGV.size > 0
-  name = ARGV[0]
-  script_name = "bin/#{name}"
-  puts "... creating #{script_name}"
-  content = <<EOS
+# Create default config file
+puts "using #{options[:config_file]} as default config file"
+if !File.exists?(options[:config_file])
+  puts "... creating config file #{options[:config_file]}"
+  FileUtils.touch options[:config_file]
+  File.chmod 0600, options[:config_file]
+  FileUtils.cp('config/kafo.yaml.example', options[:config_file])
+  if options[:answer_file]
+    `sed -i 's/^# :answer_file.*$/:answer_file: #{options[:answer_file].gsub('/', '\/')}/' #{options[:config_file]}`
+    `sed -i 's/^# :name.*$/:name: #{options[:name]}/' #{options[:config_file]}`
+  end
+end
+
+# Installer script 
+script_name = "bin/#{options[:name]}"
+puts "... creating #{script_name}"
+content = <<EOS
 #!/usr/bin/env ruby
 require 'rubygems'
+CONFIG_FILE = '#{options[:config_file]}'
 require 'kafo'
-CONFIG_FILE = "/etc/#{name}/#{name}.yaml"
 result = Kafo::KafoConfigure.run
 exit result.nil? ? 0 : result.exit_code
 EOS
-  File.open(script_name, 'w') { |file| file.write(content) }
-  FileUtils.chmod 0755, script_name
-end
+File.open(script_name, 'w') { |file| file.write(content) }
+FileUtils.chmod 0755, script_name
 
 puts "Your directory was kafofied"
 
 puts "Now you should:"
 puts "  1. upload your puppet modules to modules directory (you can use librarian-puppet project)"
-puts "  2. create default config/answers.yaml or modify config/kafo.yaml to load another answer file"
-puts "  3. run #{script_name}"
+puts "  2. create default #{options[:answer_file]} or modify #{options[:config_file]} to load another answer file"
+puts "  3. run #{script_name} to install your modules"

data/config/kafo.yaml.example

@@ -6,13 +6,17 @@
 # Your project name
 # :name: Kafo
 # Path to answer file, if the file does not exist a $pwd/config/answers.yaml is used as a fallback
-# :answer_file: /etc/kafo/kafo.yaml
+# :answer_file: /etc/kafo/answers.yaml
 # Custom installer path
 # :installer_dir: /usr/share/kafo/
 # Uncomment if you want to load puppet modules from a specific path, $pwd/modules is used by default
 # :modules_dir: /usr/share/kafo/modules
 # Similar as modules_dir but for kafo internal modules, leave nil if you don't need to change it
 # :kafo_modules_dir:
+# Enable colors? If you don't touch this, we'll autodetect terminal capabilities
+# :colors: true
+# Color scheme, we support :bright and :dark (first is better for white background, dark for black background)
+# :color_of_background: :dark
 
 ## Kafo tuning, customization of core functionality
 # :no_prefix: false

data/lib/kafo/color_scheme.rb

@@ -0,0 +1,63 @@
+require 'highline/import'
+
+module Kafo
+  class ColorScheme
+    def initialize(config)
+      @config = config
+    end
+
+    def setup
+      if @config.app[:colors]
+        HighLine.color_scheme = build_color_scheme
+        HighLine.use_color = true
+      else
+        HighLine.use_color = false
+      end
+    end
+
+    private
+
+    def build_color_scheme
+      HighLine::ColorScheme.new do |cs|
+        color_hash.keys.each do |key|
+          cs[key] = color_hash[key]
+        end
+      end
+    end
+
+    def color_hash
+      @color_hash ||= {
+          :headline => build_color(:yellow),
+          :horizontal_line => build_color(:white),
+          :important => build_color(:white),
+          :question => build_color(:green),
+          :info => build_color(:cyan),
+          :cancel => build_color(:red),
+          :run => build_color(:green),
+
+          :bad => build_color(:red),
+          :good => build_color(:green),
+      }
+    end
+
+    def build_color(color)
+      bright = @config.app[:color_of_background].to_s == 'bright'
+      color = convert_bright_to_dark(color) if bright
+
+      attributes = [ color ]
+      attributes.unshift :bold unless bright
+      attributes
+    end
+
+    def convert_bright_to_dark(color)
+      case color
+        when :white
+          :black
+        when :cyan
+          :blue
+        else
+          color
+      end
+    end
+  end
+end

data/lib/kafo/configuration.rb

@@ -1,6 +1,5 @@
 # encoding: UTF-8
 require 'yaml'
-require 'tmpdir'
 require 'kafo/puppet_module'
 require 'kafo/password_manager'
 
@@ -13,16 +12,17 @@ module Kafo
     end
 
     DEFAULT = {
-        :log_dir            => '/var/log/kafo',
-        :log_name           => 'configuration.log',
-        :log_level          => 'info',
-        :no_prefix          => false,
-        :mapping            => {},
-        :answer_file        => '/etc/kafo/kafo.yaml',
-        :installer_dir      => '.',
-        :modules_dir        => './modules',
-        :default_values_dir => '/tmp',
-        :colors             => Configuration.colors_possible?
+        :log_dir             => '/var/log/kafo',
+        :log_name            => 'configuration.log',
+        :log_level           => 'info',
+        :no_prefix           => false,
+        :mapping             => {},
+        :answer_file         => './config/answers.yaml',
+        :installer_dir       => '.',
+        :modules_dir         => './modules',
+        :default_values_dir  => '/tmp',
+        :colors              => Configuration.colors_possible?,
+        :color_of_background => :dark
     }
 
     def initialize(file, persist = true)
@@ -35,7 +35,7 @@ module Kafo
       begin
         @data = YAML.load_file(@answer_file)
       rescue Errno::ENOENT => e
-        puts "No answers file at #{@answer_file} found, can not continue"
+        puts "No answer file at #{@answer_file} found, can not continue"
         KafoConfigure.exit(:no_answer_file)
       end
 
@@ -75,11 +75,8 @@ module Kafo
 
     def params_default_values
       @params_default_values ||= begin
-        @logger.debug "Creating tmp dir within #{app[:default_values_dir]}..."
-        temp_dir = Dir.mktmpdir(nil, app[:default_values_dir])
-        KafoConfigure.register_cleanup_path temp_dir
         @logger.info "Parsing default values from puppet modules..."
-        command = PuppetCommand.new("$temp_dir=\"#{temp_dir}\" #{includes} dump_values(#{params})").append('2>&1').command
+        command = PuppetCommand.new("#{includes} dump_values(#{params})").append('2>&1').command
         @logger.debug `#{command}`
         unless $?.exitstatus == 0
           log = app[:log_dir] + '/' + app[:log_name]
@@ -88,7 +85,7 @@ module Kafo
           KafoConfigure.exit(:defaults_error)
         end
         @logger.info "... finished"
-        YAML.load_file(File.join(temp_dir, 'default_values.yaml'))
+        YAML.load_file(File.join(KafoConfigure.config.app[:default_values_dir], 'default_values.yaml'))
       end
     end
 

data/lib/kafo/exceptions.rb

@@ -3,12 +3,6 @@ module Kafo
   class ConfigurationException < StandardError
   end
 
-  class ModuleName < StandardError
-  end
-
-  class DocParseError < StandardError
-  end
-
   class ConditionError < StandardError
   end
 

data/lib/kafo/help_builders/base.rb

@@ -19,7 +19,7 @@ module Kafo
           puts "\n#{heading}:"
 
           data = by_module(items)
-          data.keys.each do |section|
+          sorted_keys(data).each do |section|
             if section == 'Generic'
               add_list(header(1, section), data[section])
             else
@@ -33,6 +33,13 @@ module Kafo
 
       private
 
+      # sorts modules by name with leaving Generic as first one
+      def sorted_keys(modules_hash)
+        keys = modules_hash.keys
+        keys.reject! { |k| k == DEFAULT_MODULE_NAME }
+        [ DEFAULT_MODULE_NAME ] + keys.sort
+      end
+
       def add_module(name, items)
         raise NotImplementedError, 'add module not defined'
       end

data/lib/kafo/kafo_configure.rb

@@ -1,5 +1,12 @@
 # encoding: UTF-8
-require 'facter'
+
+# First of all we have to store ENV variable, requiring facter can override them
+module Kafo
+  module ENV
+    LANG = ::ENV['LANG']
+  end
+end
+
 require 'pty'
 require 'clamp'
 require 'kafo/exceptions'
@@ -17,15 +24,12 @@ module Kafo
   class KafoConfigure < Clamp::Command
     include StringHelper
 
+
     class << self
       attr_accessor :config, :root_dir, :config_file, :gem_root, :temp_config_file,
                     :modules_dir, :kafo_modules_dir, :verbose, :app_options, :logger
       attr_writer :hooking
 
-      def cleanup_paths
-        @cleanup_paths ||= []
-      end
-
       def hooking
         @hooking ||= Hooking.new
       end
@@ -51,6 +55,7 @@ module Kafo
       parse clamp_app_arguments
       parse_app_arguments
       Logger.setup
+      ColorScheme.new(config).setup
 
       set_parameters # here the params gets parsed and we need app config populated
       set_options
@@ -108,7 +113,6 @@ module Kafo
     end
 
     def self.exit(code)
-      cleanup
       @exit_code = translate_exit_code(code)
       throw :exit
     end
@@ -132,26 +136,6 @@ module Kafo
       end
     end
 
-    def self.cleanup
-      # make sure default values are removed from /tmp
-      (self.cleanup_paths + ['/tmp/default_values.yaml']).each do |file|
-        logger.debug "Cleaning #{file}"
-        FileUtils.rm_rf(file)
-      end
-    end
-
-    def self.register_cleanup_path(path)
-      self.cleanup_paths<< path
-    end
-
-    def register_cleanup_path(path)
-      self.class.register_cleanup_path(path)
-    end
-
-    def cleanup_paths
-      self.class.cleanup_paths
-    end
-
     def help
       self.class.help(invocation_path, self)
     end
@@ -171,7 +155,7 @@ module Kafo
 
     def params
       @params ||= modules.map(&:params).flatten
-    rescue ModuleName => e
+    rescue KafoParsers::ModuleName => e
       puts e
       exit(:unknown_module)
     end
@@ -210,6 +194,8 @@ module Kafo
     def set_app_options
       self.class.app_option ['--[no-]colors'], :flag, 'Use color output on STDOUT',
                             :default => !!config.app[:colors]
+      self.class.app_option ['--color-of-background'], 'COLOR', 'Your terminal background is :bright or :dark',
+                            :default => config.app[:color_of_background]
       self.class.app_option ['-d', '--dont-save-answers'], :flag, 'Skip saving answers to answers.yaml?',
                             :default => !!config.app[:dont_save_answers]
       self.class.app_option '--ignore-undocumented', :flag, 'Ignore inconsistent parameter documentation',
@@ -380,6 +366,7 @@ module Kafo
     def config_file
       return CONFIG_FILE if defined?(CONFIG_FILE) && File.exists?(CONFIG_FILE)
       return '/etc/kafo/kafo.yaml' if File.exists?('/etc/kafo/kafo.yaml')
+      return "#{::RbConfig::CONFIG['sysconfdir']}/kafo/kafo.yaml" if File.exists?("#{::RbConfig::CONFIG['sysconfdir']}/kafo/kafo.yaml")
       File.join(Dir.pwd, 'config', 'kafo.yaml')
     end
 

data/lib/kafo/puppet_command.rb

@@ -23,7 +23,7 @@ module Kafo
       result = [
           "echo '$kafo_config_file=\"#{KafoConfigure.config_file}\" #{custom_answer_file} #{add_progress} #{@command}'",
           '|',
-          "RUBYLIB=#{["#{KafoConfigure.gem_root}/modules", ENV['RUBYLIB']].join(File::PATH_SEPARATOR)}",
+          "RUBYLIB=#{["#{KafoConfigure.gem_root}/modules", ::ENV['RUBYLIB']].join(File::PATH_SEPARATOR)}",
           "puppet apply #{@options.join(' ')} #{@suffix}",
       ].join(' ')
       @logger.debug result

data/lib/kafo/puppet_module.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 require 'kafo/param'
 require 'kafo/param_builder'
-require 'kafo/puppet_module_parser'
+require 'kafo_parsers/puppet_module_parser'
 require 'kafo/validator'
 
 module Kafo
@@ -11,7 +11,7 @@ module Kafo
     attr_reader :name, :identifier, :params, :dir_name, :class_name, :manifest_name, :manifest_path,
                 :groups
 
-    def initialize(identifier, parser = PuppetModuleParser)
+    def initialize(identifier, parser = KafoParsers::PuppetModuleParser)
       @identifier    = identifier
       @name          = get_name
       @dir_name      = get_dir_name

data/lib/kafo/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module Kafo
-  VERSION = "0.3.17"
+  VERSION = "0.4.0"
 end

data/lib/kafo/wizard.rb

@@ -1,15 +1,22 @@
 # encoding: UTF-8
 require 'highline/import'
+require 'kafo/color_scheme'
 require 'yaml'
 
 module Kafo
   class Wizard
+    def self.utf_support?
+      Kafo::ENV::LANG =~ /UTF-8\z/
+    end
+
+    OK = utf_support? ? '✓' : 'y'
+    NO = utf_support? ? '✗' : 'n'
+
     def initialize(kafo)
       @kafo   = kafo
       @config = kafo.config
       @name   = @config.app[:name] || 'Kafo'
       setup_terminal
-      setup_colors
     end
 
     def run
@@ -39,8 +46,10 @@ END
         say("\n" + HighLine.color('Main Config Menu', :headline))
         choose do |menu|
           menu.prompt = 'Choose an option from the menu... '
+          menu.select_by = :index
+
           @config.modules.each do |mod|
-            menu.choice "[#{mod.enabled? ? HighLine.color('✓', :run) : HighLine.color('✗', :cancel)}] Configure #{mod.name}" do
+            menu.choice "[#{mod.enabled? ? HighLine.color(OK, :run) : HighLine.color(NO, :cancel)}] Configure #{mod.name}" do
               configure_module(mod)
             end
           end
@@ -69,6 +78,8 @@ END
         say("\n" + HighLine.color("Module #{mod.name} configuration", :headline))
         choose do |menu|
           menu.prompt = 'Choose an option from the menu... '
+          menu.select_by = :index
+
           menu.choice("Enable/disable #{mod.name} module, current value: #{HighLine.color(mod.enabled?.to_s, :info)}") { turn_module(mod) }
           if mod.enabled?
             render_params(mod.primary_parameter_group.params, menu)
@@ -149,33 +160,5 @@ END
       $terminal.wrap_at = data.first > 80 ? 80 : data.first if data.first
       $terminal.page_at = data.last if data.last
     end
-
-    def color_hash
-      @color_hash ||= {
-          :headline        => [:bold, :yellow, :on_black],
-          :horizontal_line => [:bold, :white, :on_black],
-          :important       => [:bold, :white, :on_black],
-          :question        => [:bold, :green, :on_black],
-          :info            => [:bold, :cyan, :on_black],
-          :cancel          => [:bold, :red, :on_black],
-          :run             => [:bold, :green, :on_black],
-      }
-    end
-
-    # setup colour scheme for prompts
-    def setup_colors
-      colors = HighLine::ColorScheme.new do |cs|
-        color_hash.keys.each do |key|
-          cs[key] = color_hash[key]
-        end
-      end
-
-      nocolors = HighLine::ColorScheme.new do |cs|
-        color_hash.keys.each { |k| cs[k.to_sym] = [] }
-      end
-
-      HighLine.color_scheme = @config.app[:colors] ? colors : nocolors
-    end
-
   end
 end

data/modules/kafo_configure/lib/puppet/parser/functions/dump_values.rb

@@ -9,10 +9,7 @@ module Puppet::Parser::Functions
       [arg, found_value.nil? ? arg : found_value]
     end
     data = Hash[data]
-
-    dump_dir = lookupvar('temp_dir')
-    file_name = "#{dump_dir}/default_values.yaml"
-
-    File.open(file_name, File::WRONLY|File::CREAT|File::EXCL, 0600) { |file| file.write(YAML.dump(data)) }
+    dump_dir = YAML.load_file(lookupvar('kafo_config_file'))[:default_values_dir]
+    File.open("#{dump_dir}/default_values.yaml", 'w') { |file| file.write(YAML.dump(data)) }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kafo
 version: !ruby/object:Gem::Version
-  version: 0.3.17
+  version: 0.4.0
 platform: ruby
 authors:
 - Marek Hulan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-08 00:00:00.000000000 Z
+date: 2014-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: kafo_parsers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: puppet
+  name: kafo_parsers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -95,19 +109,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: puppet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: logging
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +156,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.21
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.21
 - !ruby/object:Gem::Dependency
   name: powerbar
   requirement: !ruby/object:Gem::Requirement
@@ -181,8 +195,6 @@ files:
 - config/config_header.txt
 - lib/kafo/condition.rb
 - lib/kafo/puppet_module.rb
-- lib/kafo/puppet_module_parser.rb
-- lib/kafo/doc_parser.rb
 - lib/kafo/password_manager.rb
 - lib/kafo/configuration.rb
 - lib/kafo/validator.rb
@@ -205,6 +217,7 @@ files:
 - lib/kafo/hooking.rb
 - lib/kafo/string_helper.rb
 - lib/kafo/logger.rb
+- lib/kafo/color_scheme.rb
 - lib/kafo/param_group.rb
 - lib/kafo/progress_bars/colored.rb
 - lib/kafo/progress_bars/black_white.rb

data/lib/kafo/doc_parser.rb

@@ -1,129 +0,0 @@
-# encoding: UTF-8
-require 'rdoc'
-require 'rdoc/markup' # required for RDoc < 0.9.5
-require 'rdoc/markup/parser' # required for RDoc < 0.9.5
-
-module Kafo
-  class DocParser
-    ATTRIBUTE_LINE   = /^(condition|type)\s*:\s*(.*)/
-    HEADER_CONDITION = /\A(.+)\s*condition:\s*(.+)\Z/
-
-    def initialize(text)
-      @text           = text
-      @nesting_buffer = []
-      @docs           = {}
-      @groups         = {}
-      @conditions     = {}
-      @types          = Hash.new('string')
-      @rdoc           = rdoc_parser.parse(@text)
-    end
-
-    attr_reader :docs, :groups, :types, :conditions
-
-    # items is array of RDoc::Markup::* on one level
-    def parse(items = @rdoc.parts)
-      items.each do |item|
-        if item.is_a?(RDoc::Markup::Heading)
-          parse_header(item)
-        elsif item.is_a?(RDoc::Markup::List) && item.respond_to?(:items)
-          parse(item.items)
-        elsif item.is_a?(RDoc::Markup::ListItem)
-          parse_paragraph(item)
-        end
-      end
-      self
-    end
-
-    private
-
-    def parse_paragraph(para)
-      # Skip rdoc paras that aren't paragraphs
-      return unless (para.parts.to_s.scan("RDoc::Markup::Paragraph") == ["RDoc::Markup::Paragraph"])
-      # RDoc (>= 4) makes label an array
-      label = para.label.is_a?(Array) ? para.label.first : para.label
-      # Documentation must be a list - if there's no label then skip
-      return if label.nil?
-      key              = label.gsub(/[^A-Za-z0-9_-]/, '')
-      @groups[key]     = current_groups
-      text_parts       = para.parts.first.parts.map!(&:strip)
-      attributes, docs = text_parts.partition { |line| line =~ ATTRIBUTE_LINE }
-      parse_attributes(key, attributes)
-      @docs[key] = docs
-    end
-
-    def parse_attributes(parameter, attributes)
-      condition = nil
-      attributes.each do |attribute|
-        data        = attribute.match(ATTRIBUTE_LINE)
-        name, value = data[1], data[2]
-
-        case name
-          when 'type'
-            @types[parameter] = value
-          when 'condition'
-            if condition.nil?
-              condition = value
-            else
-              raise DocParseError, "Two or more conditions defined for #{name}"
-            end
-          else
-            raise DocParseError, "Unknown attribute #{name}"
-        end
-
-      end
-      condition              = [current_condition, condition].compact.join(' && ')
-      @conditions[parameter] = condition.empty? ? nil : condition
-    end
-
-    def parse_header(heading)
-      if heading.level > current_level
-        @nesting_buffer.push nesting(heading)
-      elsif heading.level == current_level
-        @nesting_buffer.pop
-        @nesting_buffer.push nesting(heading)
-      else
-        while current_level >= heading.level do
-          @nesting_buffer.pop
-        end
-        @nesting_buffer.push nesting(heading)
-      end
-    end
-
-    def nesting(heading)
-      if heading.text =~ HEADER_CONDITION
-        text, condition = $1, $2
-      else
-        text, condition = heading.text, nil
-      end
-      Nesting.new(text.strip, heading.level, condition)
-    end
-
-    def current_groups
-      @nesting_buffer.map(&:name)
-    end
-
-    def current_level
-      current_nesting.nil? ? 0 : current_nesting.level
-    end
-
-    def current_condition
-      condition = @nesting_buffer.map(&:condition).select { |c| !c.nil? }.join(' && ')
-      condition.empty? ? nil : condition
-    end
-
-    def current_nesting
-      @nesting_buffer.last
-    end
-
-    def rdoc_parser
-      if RDoc::Markup.respond_to?(:parse)
-        RDoc::Markup
-      else # RDoc < 3.10.0
-        RDoc::Markup::Parser
-      end
-    end
-
-    class Nesting < Struct.new(:name, :level, :condition);
-    end
-  end
-end

data/lib/kafo/puppet_module_parser.rb

@@ -1,78 +0,0 @@
-# encoding: UTF-8
-require 'puppet'
-require 'kafo/doc_parser'
-
-module Kafo
-  # Based on ideas from puppet-parse by Johan van den Dorpe
-  # we don't build any tree structure since e.g. params from doc does not
-  # have to be defined in puppet DSL and vice versa, we just gather all info
-  # we can read from the whole manifest
-  class PuppetModuleParser
-    def self.parse(file)
-      content = new(file)
-      docs    = content.docs
-
-      data              = {
-          :values      => content.values,
-          :validations => content.validations
-      }
-      data[:parameters] = data[:values].keys
-      data.merge!(docs)
-      data
-    end
-
-    def initialize(file)
-      @file = file
-      raise ModuleName, "File not found #{file}, check you answer file" unless File.exists?(file)
-      Puppet.settings[:confdir] ||= '/' # just some stubbing
-      if Puppet::Node::Environment.respond_to?(:create)
-        env = Puppet::Node::Environment.create(:production, [], '')
-      else
-        env = Puppet::Node::Environment.new(:production)
-      end
-      parser = Puppet::Parser::Parser.new(env)
-      parser.import(@file)
-
-      # Find object corresponding to class defined in init.pp in list of hostclasses
-      parser.environment.known_resource_types.hostclasses.each do |ast_objects|
-        ast_type = ast_objects.last
-        @object = ast_type if ast_type.file == file
-      end
-
-      parser
-    end
-
-    # TODO - store parsed object type (Puppet::Parser::AST::Variable must be dumped later)
-    def values
-      parameters = {}
-      arguments  = @object.respond_to?(:arguments) ? @object.arguments : {}
-      arguments.each { |k, v| parameters[k] = v.respond_to?(:value) ? v.value : nil }
-      parameters
-    end
-
-    def validations(param = nil)
-      @object.code.select { |stmt| stmt.is_a?(Puppet::Parser::AST::Function) && stmt.name =~ /^validate_/ }
-    end
-
-    # returns data in following form
-    # {
-    #   :docs => { $param1 => 'documentation without types and conditions'}
-    #   :types => { $param1 => 'boolean'},
-    #   :groups => { $param1 => ['Parameters', 'Advanced']},
-    #   :conditions => { $param1 => '$db_type == "mysql"'},
-    # }
-    def docs
-      data = { :docs => {}, :types => {}, :groups => {}, :conditions => {} }
-      if @object.nil?
-        raise DocParseError, "no documentation found for manifest #{@file}, parsing error?"
-      elsif !@object.doc.nil?
-        parser            = DocParser.new(@object.doc).parse
-        data[:docs]       = parser.docs
-        data[:groups]     = parser.groups
-        data[:types]      = parser.types
-        data[:conditions] = parser.conditions
-      end
-      data
-    end
-  end
-end