kafo 0.2.2 → 0.3.0

data/lib/kafo/logger.rb

@@ -2,64 +2,66 @@
 require 'fileutils'
 require 'logging'
 
-class Logger
-  class << self
-    attr_accessor :loggers
-  end
+module Kafo
+  class Logger
+    class << self
+      attr_accessor :loggers
+    end
 
-  PATTERN        = "[%5l %d %c] %m\n"
-  Logging.color_scheme('bright',
-                       :levels => {
-                           :info  => :green,
-                           :warn  => :yellow,
-                           :error => :red,
-                           :fatal => [:white, :on_red]
-                       },
-                       :date   => :blue,
-                       :logger => :cyan,
-                       :line   => :yellow,
-                       :file   => :yellow,
-                       :method => :yellow
-  )
-  COLOR_LAYOUT   = Logging::Layouts::Pattern.new(:pattern => PATTERN, :color_scheme => 'bright')
-  NOCOLOR_LAYOUT = Logging::Layouts::Pattern.new(:pattern => PATTERN, :color_scheme => nil)
+    PATTERN = "[%5l %d %c] %m\n"
+    Logging.color_scheme('bright',
+                         :levels => {
+                             :info  => :green,
+                             :warn  => :yellow,
+                             :error => :red,
+                             :fatal => [:white, :on_red]
+                         },
+                         :date   => :blue,
+                         :logger => :cyan,
+                         :line   => :yellow,
+                         :file   => :yellow,
+                         :method => :yellow
+    )
+    COLOR_LAYOUT   = Logging::Layouts::Pattern.new(:pattern => PATTERN, :color_scheme => 'bright')
+    NOCOLOR_LAYOUT = Logging::Layouts::Pattern.new(:pattern => PATTERN, :color_scheme => nil)
 
-  def self.setup
-    begin
-      FileUtils.mkdir_p(KafoConfigure.config.app[:log_dir], :mode => 0750)
-    rescue Errno::EACCES => e
-      puts "No permissions to create log dir #{KafoConfigure.config.app[:log_dir]}"
-    end
+    def self.setup
+      begin
+        FileUtils.mkdir_p(KafoConfigure.config.app[:log_dir], :mode => 0750)
+      rescue Errno::EACCES => e
+        puts "No permissions to create log dir #{KafoConfigure.config.app[:log_dir]}"
+      end
 
-    logger   = Logging.logger['main']
-    filename = "#{KafoConfigure.config.app[:log_dir]}/#{KafoConfigure.config.app[:log_name] || 'configure.log'}"
-    begin
-      logger.appenders = ::Logging.appenders.rolling_file('configure',
-                                                          :filename => filename,
-                                                          :layout   => NOCOLOR_LAYOUT,
-                                                          :truncate => true
-      )
-      # set owner and group (it's ignored if attribute is nil)
-      FileUtils.chown KafoConfigure.config.app[:log_owner], KafoConfigure.config.app[:log_group], filename
-    rescue ArgumentError => e
-      puts "File #{filename} not writeable, won't log anything to file!"
-    end
+      logger   = Logging.logger['main']
+      filename = "#{KafoConfigure.config.app[:log_dir]}/#{KafoConfigure.config.app[:log_name] || 'configure.log'}"
+      begin
+        logger.appenders = ::Logging.appenders.rolling_file('configure',
+                                                            :filename => filename,
+                                                            :layout   => NOCOLOR_LAYOUT,
+                                                            :truncate => true
+        )
+        # set owner and group (it's ignored if attribute is nil)
+        FileUtils.chown KafoConfigure.config.app[:log_owner], KafoConfigure.config.app[:log_group], filename
+      rescue ArgumentError => e
+        puts "File #{filename} not writeable, won't log anything to file!"
+      end
 
-    logger.level = KafoConfigure.config.app[:log_level]
-    self.loggers = [logger]
-  end
+      logger.level = KafoConfigure.config.app[:log_level]
+      self.loggers = [logger]
+    end
 
-  def self.setup_verbose
-    logger           = Logging.logger['verbose']
-    logger.level     = KafoConfigure.config.app[:verbose_log_level]
-    layout           = KafoConfigure.config.app[:colors] ? COLOR_LAYOUT : NOCOLOR_LAYOUT
-    logger.appenders = [::Logging.appenders.stdout(:layout => layout)]
-    self.loggers<< logger
-  end
+    def self.setup_verbose
+      logger           = Logging.logger['verbose']
+      logger.level     = KafoConfigure.config.app[:verbose_log_level]
+      layout           = KafoConfigure.config.app[:colors] ? COLOR_LAYOUT : NOCOLOR_LAYOUT
+      logger.appenders = [::Logging.appenders.stdout(:layout => layout)]
+      self.loggers<< logger
+    end
 
-  %w(fatal error warn info debug).each do |name|
-    define_method(name) do |*args, &block|
-      self.class.loggers.each { |logger| logger.send name, *args, &block }
+    %w(fatal error warn info debug).each do |name|
+      define_method(name) do |*args, &block|
+        self.class.loggers.each { |logger| logger.send name, *args, &block }
+      end
     end
   end
 end

data/lib/kafo/param.rb

@@ -1,82 +1,105 @@
 # encoding: UTF-8
-class Param
-  attr_reader :name, :module
-  attr_accessor :default, :doc, :value_set
+require 'kafo/condition'
 
-  def initialize(builder, name)
-    @name = name
-    @module = builder
-  end
+module Kafo
+  class Param
+    attr_reader :name, :module
+    attr_accessor :default, :doc, :value_set, :condition
+    attr_writer :groups
 
-  # we use @value_set flag because even nil can be valid value
-  def value
-    @value_set ? @value : default
-  end
+    def initialize(builder, name)
+      @name   = name
+      @module = builder
+    end
 
-  def value=(value)
-    @value_set = true
-    @value = value == 'UNDEF' ? nil : value
-  end
+    def groups
+      @groups || []
+    end
 
-  def module_name
-    self.module.name
-  end
+    # we use @value_set flag because even nil can be valid value
+    def value
+      @value_set ? @value : default
+    end
 
-  def to_s
-    "#<#{self.class}:#{self.object_id} @name=#{name.inspect} @default=#{default.inspect} @value=#{value.inspect}>"
-  end
+    def value=(value)
+      @value_set = true
+      @value     = value == 'UNDEF' ? nil : value
+    end
 
-  def set_default(defaults)
-    if default == 'UNSET'
-      self.value = nil
-    else
-      self.value = (value = defaults[default]) == :undef ? nil : value
+    def module_name
+      self.module.name
     end
-  end
 
-  def set_value_by_config(config)
-    base = config[module_name]
-    self.value = base[name] if base.has_key?(name)
-  end
+    def to_s
+      "#<#{self.class}:#{self.object_id} @name=#{name.inspect} @default=#{default.inspect} @value=#{value.inspect}>"
+    end
 
-  def valid?
-    validations = self.module.validations(self)
-    # we get validations that can also run on other arguments, we need to take only current param
-    # also we want to clone validations so we don't interfere
-    validations.map! do |v|
-      v = v.clone
-      if v.name == 'validate_re'
-        # validate_re does not take more variables as arguments, instead we need to pass all arguments
-        args = v.arguments
+    def set_default(defaults)
+      if default == 'UNSET'
+        self.value = nil
       else
-        args = v.arguments.select { |a| a.to_s == "$#{self.name}" }
+        self.value = (value = defaults[default]) == :undef ? nil : value
       end
-      v.arguments = Puppet::Parser::AST::ASTArray.new :children => args
-      v
     end
 
-    validator = Validator.new([self])
-    validations.map! do |v|
-      result = v.evaluate(validator)
-      # validate_re returns nil if succeeds
-      result = true if v.name == 'validate_re' && result.nil?
-      result
+    def set_value_by_config(config)
+      base       = config[module_name]
+      self.value = base[name] if base.has_key?(name)
     end
 
-    validations.all?
-  end
+    def valid?
+      validations = self.module.validations(self)
+      # we get validations that can also run on other arguments, we need to take only current param
+      # also we want to clone validations so we don't interfere
+      validations.map! do |v|
+        v = v.clone
+        if v.name == 'validate_re'
+          # validate_re does not take more variables as arguments, instead we need to pass all arguments
+          args = v.arguments
+        else
+          args = v.arguments.select { |a| a.to_s == "$#{self.name}" }
+        end
+        v.arguments = Puppet::Parser::AST::ASTArray.new :children => args
+        v
+      end
 
-  # To be overwritten in children
-  def multivalued?
-    false
-  end
+      validator = Validator.new([self])
+      validations.map! do |v|
+        result = v.evaluate(validator)
+        # validate_re returns nil if succeeds
+        result = true if v.name == 'validate_re' && result.nil?
+        result
+      end
+
+      validations.all?
+    end
+
+    # To be overwritten in children
+    def multivalued?
+      false
+    end
+
+    def <=> o
+      unless KafoConfigure.config.app[:no_prefix]
+        r = self.module_name <=> o.module_name
+        return r unless r == 0
+      end
+      self.name <=> o.name
+    end
+
+    def visible?(context = [])
+      condition.nil? || condition.empty? ? true : evaluate_condition(context)
+    end
+
+    def condition_value
+      value.to_s
+    end
+
+    private
 
-  def <=> o
-    unless KafoConfigure.config.app[:no_prefix]
-      r = self.module_name <=> o.module_name
-      return r unless r == 0
+    def evaluate_condition(context = [])
+      Condition.new(condition, context).evaluate
     end
-    self.name <=> o.name
   end
 end
 

data/lib/kafo/param_builder.rb

@@ -1,62 +1,86 @@
 # encoding: UTF-8
-class ParamBuilder
-  ATTRIBUTE_RE = /^(type):(.*)/
+require 'kafo/param_group'
 
-  def initialize(mod, data)
-    @data   = data
-    @module = mod
-  end
+module Kafo
+  class ParamBuilder
+    def initialize(mod, data)
+      @data   = data
+      @module = mod
+      @groups = []
+    end
 
-  def validate
-    return true if KafoConfigure.config.app[:ignore_undocumented]
+    def validate
+      return true if KafoConfigure.config.app[:ignore_undocumented]
 
-    parameters = @data['parameters'].keys.sort
-    docs       = @data['docs'].keys.sort
-    if parameters == docs
-      return true
-    else
-      undocumented = parameters - docs
-      raise ConfigurationException, "undocumented parameters in #{@module.name}: #{undocumented.join(', ')}" unless undocumented.empty?
-      deleted = docs - parameters
-      raise ConfigurationException, "documentation mentioned unknown parameters in #{@module.name}: #{deleted.join(', ')}" unless deleted.empty?
-      raise ConfigurationException, "unknown error in configuration in #{@module.name}"
+      parameters = @data[:parameters].sort
+      docs       = @data[:docs].keys.sort
+      if parameters == docs
+        return true
+      else
+        undocumented = parameters - docs
+        raise ConfigurationException, "undocumented parameters in #{@module.name}: #{undocumented.join(', ')}" unless undocumented.empty?
+        deleted = docs - parameters
+        raise ConfigurationException, "documentation mentioned unknown parameters in #{@module.name}: #{deleted.join(', ')}" unless deleted.empty?
+        raise ConfigurationException, "unknown error in configuration in #{@module.name}"
+      end
     end
-  end
 
-  def build_params
-    @data['parameters'].keys.map do |param_name|
-      build(param_name, @data['parameters'][param_name], @data['docs'][param_name])
+    def build_params
+      @data[:parameters].map do |param_name|
+        build(param_name, @data)
+      end
     end
-  end
 
-  def build(name, default, docs)
-    param         = get_type(docs).new(@module, name)
-    param.default = default
-    param.doc     = get_documentation(docs)
-    param
-  end
 
-  private
+    def build_param_groups(params)
+      data = Hash[get_parameters_groups_by_param_name]
+      data.each do |param_name, param_groups|
+        param_groups.each_with_index do |group_name, i|
+          param_group = find_or_build_group(group_name)
+          if i + 1 < param_groups.size
+            param_group.add_child find_or_build_group(param_groups[i + 1])
+          end
 
-  def get_documentation(docs)
-    return nil if docs.nil?
-    docs.select { |line| line !~ ATTRIBUTE_RE }
-  end
+          param_group = find_or_build_group(param_groups.last)
+          param       = params.detect { |p| p.name == param_name }
+          param_group.add_param param unless param.nil?
+        end
+      end
 
-  def get_type(docs)
-    type = (get_attributes(docs)[:type] || '').capitalize
-    type.empty? || !Params.const_defined?(type) ? Params::String : Params.const_get(type)
-  end
+      # top level groups
+      data.values.map(&:first).compact.uniq.map { |name| @groups.detect { |g| g.name == name } }
+    end
 
-  def get_attributes(docs)
-    data = {}
-    return data if docs.nil?
+    def build(name, data)
+      param           = get_type(data[:types][name]).new(@module, name)
+      param.default   = data[:values][name]
+      param.doc       = data[:docs][name]
+      param.groups    = data[:groups][name]
+      param.condition = data[:conditions][name]
+      param
+    end
 
-    docs.each do |line|
-      if line =~ ATTRIBUTE_RE
-        data[$1.to_sym] = $2
+    private
+
+    def get_parameters_groups_by_param_name
+      @data[:groups].map do |name, groups|
+        [name, groups.select { |g| g =~ /parameters/i }]
       end
     end
-    data
+
+    def find_or_build_group(name)
+      param_group = @groups.detect { |g| g.name == name }
+      unless param_group
+        param_group        = ParamGroup.new(name)
+        param_group.module = @module
+        @groups.push param_group
+      end
+      param_group
+    end
+
+    def get_type(type)
+      type = type.capitalize
+      Params.const_defined?(type) ? Params.const_get(type) : raise(TypeError, "undefined parameter type '#{type}'")
+    end
   end
 end

data/lib/kafo/param_group.rb

@@ -0,0 +1,27 @@
+#encoding: UTF-8
+
+module Kafo
+  class ParamGroup
+    attr_reader :children, :params, :name
+    attr_accessor :module
+
+
+    def initialize(name)
+      @children = []
+      @params   = []
+      @name     = name
+    end
+
+    def formatted_name
+      @formatted_name ||= @name.sub(/:\Z/,'')
+    end
+
+    def add_child(group)
+      @children.push group unless @children.include?(group)
+    end
+
+    def add_param(param)
+      @params.push param unless @params.include?(param)
+    end
+  end
+end

data/lib/kafo/params/array.rb

@@ -1,18 +1,20 @@
-module Params
-  class Array < Param
-    def value=(value)
-      super
-      @value = typecast(@value)
-    end
+module Kafo
+  module Params
+    class Array < Param
+      def value=(value)
+        super
+        @value = typecast(@value)
+      end
 
-    def multivalued?
-      true
-    end
+      def multivalued?
+        true
+      end
 
-    private
+      private
 
-    def typecast(value)
-      value.nil? ? nil : [value].flatten
+      def typecast(value)
+        value.nil? ? nil : [value].flatten
+      end
     end
   end
 end