kafo 0.2.2 → 0.3.0

data/lib/kafo/configuration.rb

@@ -3,127 +3,129 @@ require 'yaml'
 require 'kafo/puppet_module'
 require 'kafo/password_manager'
 
-class Configuration
-  attr_reader :config_file, :answer_file
+module Kafo
+  class Configuration
+    attr_reader :config_file, :answer_file
 
-  def self.colors_possible?
-    !`which tput 2> /dev/null`.empty? && `tput colors`.to_i > 0
-  end
-
-  DEFAULT = {
-      :log_dir            => '/var/log/kafo',
-      :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?
-  }
-
-  def initialize(file, persist = true)
-    @config_file = file
-    @persist = persist
-    configure_application
-    @logger = KafoConfigure.logger
-
-    @answer_file = app[:answer_file]
-    begin
-      @data        = YAML.load_file(@answer_file)
-    rescue Errno::ENOENT => e
-      puts "No answers file at #{@answer_file} found, can not continue"
-      KafoConfigure.exit(:no_answer_file)
+    def self.colors_possible?
+      !`which tput 2> /dev/null`.empty? && `tput colors`.to_i > 0
     end
 
-    @config_dir  = File.dirname(@config_file)
-  end
-
-  def save_configuration(configuration)
-    return true unless @persist
-    FileUtils.touch @config_file
-    File.chmod 0600, @config_file
-    File.open(@config_file, 'w') { |file| file.write(format(YAML.dump(configuration))) }
-  end
-
-  def configure_application
-    result = app
-    save_configuration(result)
-    result
-  end
-
-  def app
-    @app ||= begin
+    DEFAULT = {
+        :log_dir            => '/var/log/kafo',
+        :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?
+    }
+
+    def initialize(file, persist = true)
+      @config_file = file
+      @persist     = persist
+      configure_application
+      @logger = KafoConfigure.logger
+
+      @answer_file = app[:answer_file]
       begin
-        configuration = YAML.load_file(@config_file)
-      rescue => e
-        configuration = {}
+        @data = YAML.load_file(@answer_file)
+      rescue Errno::ENOENT => e
+        puts "No answers file at #{@answer_file} found, can not continue"
+        KafoConfigure.exit(:no_answer_file)
       end
 
-      result            = DEFAULT.merge(configuration || {})
-      result[:password] ||= PasswordManager.new.password
+      @config_dir = File.dirname(@config_file)
+    end
+
+    def save_configuration(configuration)
+      return true unless @persist
+      FileUtils.touch @config_file
+      File.chmod 0600, @config_file
+      File.open(@config_file, 'w') { |file| file.write(format(YAML.dump(configuration))) }
+    end
+
+    def configure_application
+      result = app
+      save_configuration(result)
       result
     end
-  end
 
-  def modules
-    @modules ||= @data.keys.map { |mod| PuppetModule.new(mod).parse }
-  end
+    def app
+      @app ||= begin
+        begin
+          configuration = YAML.load_file(@config_file)
+        rescue => e
+          configuration = {}
+        end
+
+        result            = DEFAULT.merge(configuration || {})
+        result[:password] ||= PasswordManager.new.password
+        result
+      end
+    end
 
-  def params_default_values
-    @params_default_values ||= begin
-      @logger.info "Parsing default values from puppet modules..."
-      command = PuppetCommand.new("#{includes} dump_values(#{params})").append('2>&1').command
-      @logger.debug `#{command}`
-      unless $?.exitstatus == 0
-        log = app[:log_dir] + '/' + app[:log_name]
-        puts "Could not get default values, check log file at #{log} for more information"
-        @logger.error "Could not get default values, cannot continue"
-        KafoConfigure.exit(:defaults_error)
+    def modules
+      @modules ||= @data.keys.map { |mod| PuppetModule.new(mod).parse }
+    end
+
+    def params_default_values
+      @params_default_values ||= begin
+        @logger.info "Parsing default values from puppet modules..."
+        command = PuppetCommand.new("#{includes} dump_values(#{params})").append('2>&1').command
+        @logger.debug `#{command}`
+        unless $?.exitstatus == 0
+          log = app[:log_dir] + '/' + app[:log_name]
+          puts "Could not get default values, check log file at #{log} for more information"
+          @logger.error "Could not get default values, cannot continue"
+          KafoConfigure.exit(:defaults_error)
+        end
+        @logger.info "... finished"
+        YAML.load_file(File.join(KafoConfigure.config.app[:default_values_dir], 'default_values.yaml'))
       end
-      @logger.info "... finished"
-      YAML.load_file(File.join(KafoConfigure.config.app[:default_values_dir], 'default_values.yaml'))
     end
-  end
 
-  # if a value is a true we return empty hash because we have no specific options for a
-  # particular puppet module
-  def [](key)
-    value = @data[key]
-    value.is_a?(Hash) ? value : {}
-  end
+    # if a value is a true we return empty hash because we have no specific options for a
+    # particular puppet module
+    def [](key)
+      value = @data[key]
+      value.is_a?(Hash) ? value : {}
+    end
 
-  def module_enabled?(mod)
-    value = @data[mod.is_a?(String) ? mod : mod.name]
-    !!value || value.is_a?(Hash)
-  end
+    def module_enabled?(mod)
+      value = @data[mod.is_a?(String) ? mod : mod.name]
+      !!value || value.is_a?(Hash)
+    end
 
-  def config_header
-    files = [ app[:config_header_file], File.join(KafoConfigure.gem_root, '/config/config_header.txt') ].compact
-    file = files.select { |f| File.exists?(f) }.first
-    @config_header ||= file.nil? ? '' : File.read(file)
-  end
+    def config_header
+      files          = [app[:config_header_file], File.join(KafoConfigure.gem_root, '/config/config_header.txt')].compact
+      file           = files.select { |f| File.exists?(f) }.first
+      @config_header ||= file.nil? ? '' : File.read(file)
+    end
 
-  def store(data, file = nil)
-    filename = file || answer_file
-    FileUtils.touch filename
-    File.chmod 0600, filename
-    File.open(filename, 'w') { |file| file.write(config_header + format(YAML.dump(data))) }
-  end
+    def store(data, file = nil)
+      filename = file || answer_file
+      FileUtils.touch filename
+      File.chmod 0600, filename
+      File.open(filename, 'w') { |file| file.write(config_header + format(YAML.dump(data))) }
+    end
 
-  private
+    private
 
-  def includes
-    modules.map { |mod| "include #{mod.dir_name}::params" }.join(' ')
-  end
+    def includes
+      modules.map { |mod| "include #{mod.dir_name}::params" }.join(' ')
+    end
 
-  def params
-    params = modules.map(&:params).flatten
-    params = params.select { |p| p.default != 'UNSET' }
-    params.map { |param| "#{param.default}" }.join(',')
-  end
+    def params
+      params = modules.map(&:params).flatten
+      params = params.select { |p| p.default != 'UNSET' }
+      params.map { |param| "#{param.default}" }.join(',')
+    end
 
-  def format(data)
-    data.gsub('!ruby/sym ', ':')
+    def format(data)
+      data.gsub('!ruby/sym ', ':')
+    end
   end
 end

data/lib/kafo/doc_parser.rb

@@ -0,0 +1,129 @@
+# 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/exceptions.rb

@@ -1,6 +1,17 @@
 # encoding: UTF-8
-class ConfigurationException < StandardError
-end
+module Kafo
+  class ConfigurationException < StandardError
+  end
+
+  class ModuleName < StandardError
+  end
+
+  class DocParseError < StandardError
+  end
+
+  class ConditionError < StandardError
+  end
 
-class ModuleName < StandardError
+  class TypeError < StandardError
+  end
 end

data/lib/kafo/help_builder.rb

@@ -0,0 +1,3 @@
+require 'kafo/help_builders/base'
+require 'kafo/help_builders/basic'
+require 'kafo/help_builders/advanced'

data/lib/kafo/help_builders/advanced.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Kafo
+  module HelpBuilders
+    class Advanced < Base
+      def add_module(name, items)
+        data = by_parameter_groups(items)
+        if data.keys.size > 1
+          puts module_header(name + ':')
+          data.keys.each do |group|
+            add_list(header(2, group), data[group])
+          end
+        else
+          add_list(module_header(name), data[data.keys.first])
+        end
+      end
+    end
+  end
+end

data/lib/kafo/help_builders/base.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+module Kafo
+  module HelpBuilders
+    DEFAULT_GROUP_NAME   = 'Basic'
+    DEFAULT_MODULE_NAME  = 'Generic'
+    IGNORE_IN_GROUP_NAME = /\s*parameters:?/
+
+    class Base < Clamp::Help::Builder
+      include StringHelper
+
+      def initialize(params)
+        super()
+        @params = params
+      end
+
+      def add_list(heading, items)
+        if heading == 'Options'
+          puts "\n#{heading}:"
+
+          data = by_module(items)
+          data.keys.each do |section|
+            if section == 'Generic'
+              add_list(header(1, section), data[section])
+            else
+              add_module(section, data[section])
+            end
+          end
+        else
+          super
+        end
+      end
+
+      private
+
+      def add_module(name, items)
+        raise NotImplementedError, 'add module not defined'
+      end
+
+      def header(level, text)
+        level(level) + ' ' + text
+      end
+
+      def module_header(name)
+        "\n" + header(1, 'Module ' + name)
+      end
+
+      def level(n)
+        '=' * n
+      end
+
+      def by_parameter_groups(items)
+        data = Hash.new { |h, k| h[k] = [] }
+        params_mapping(items).each do |item, param|
+          data[group(param)].push item
+        end
+        data
+      end
+
+      def group(param)
+        name = param.groups.reverse.find { |group| group.include?('parameters') }
+        name.nil? ? DEFAULT_GROUP_NAME : name.sub(IGNORE_IN_GROUP_NAME, '')
+      end
+
+      def by_module(help_items)
+        data = Hash.new { |h, k| h[k] = [] }
+        params_mapping(help_items).each do |item, param|
+          data[param.nil? ? DEFAULT_MODULE_NAME : param.module_name].push item
+        end
+        data
+      end
+
+      def params_mapping(items)
+        items.map { |i| [i, parametrization[i.help.first.strip]] }
+      end
+
+      def parametrization
+        @parametrization ||= Hash[@params.map { |p| [parametrize(p), p] }]
+      end
+    end
+  end
+end