kafo 0.9.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9aa7023bba923d94e836d8a08738bc10953938e
-  data.tar.gz: 08b552989a2cbc3855b8d76d2bc06404372d89d9
+  metadata.gz: 37920206589ad542c671af010f5b8dd1bb02dff0
+  data.tar.gz: 3e001186cf0bd9f809a28d92e5223d6345e264e8
 SHA512:
-  metadata.gz: c74d44e98884a8b71c2c89518f74b5a3607da2dace7ec9811337bdaaae595fb39d4d97a033b7eee0340ff1c919d0e48eb6325fd3b424a5c45e3151c11ad1a017
-  data.tar.gz: 92a489f199664a79ef65b43972c47dfacc45471c5ef9d76aac8013bd7e25c7998ab29dbd38c51d87426f2b0e21dd2c1693d02592a9fefa5b05aba8ff1eb559e7
+  metadata.gz: c59eac78e4965f90f98b1bab03275aa2044e724f71e7ed3f90339e7dbc0201812d3cb04bf1ddd0b3b390a309a1c3455620bcd961cadba6fcca01c9b6e581a9f1
+  data.tar.gz: 797b544447e37f68faf90fe2a54afd033bda2254fa27d18b7c93d1c9ba453644db8b0c145ce9588e5c146507eebdaa60f59ac3321ad379d6f1b64fa3587f05a9

data/README.md

@@ -400,10 +400,10 @@ Example:
 #
 # $enc::                    Should foreman act as an external node classifier (manage puppet class
 #                           assignments)
-#                           type:boolean
+#
 class foreman (
-  $foreman_url            = $foreman::params::foreman_url,
-  $enc                    = $foreman::params::enc
+  String $foreman_url = $foreman::params::foreman_url,
+  Boolean $enc        = $foreman::params::enc
 ) {
   class { 'foreman::install': }
 }
@@ -445,20 +445,45 @@ the particular parameter belongs.
 
 ## Argument types
 
-By default all arguments that are parsed from puppet are treated as strings.
-If you want to indicate that a parameter has a particular type you can do it
-in the puppet manifest documentation like this
+When using Puppet 4 or newer, the data type will be read from the parameter
+list and defaults to Puppet's [Any](https://docs.puppet.com/puppet/latest/reference/lang_data_abstract.html#any)
+data type, which Kafo handles as a basic string with no validation.
+
+If more specific data types, such as `Optional[Array[2]]` or similar are
+given in the [parameter list](https://docs.puppet.com/puppet/4.5/reference/lang_data_type.html#usage)
+then Kafo will parse and validate parameters values according to the
+specification.
+
+```puppet
+class example (
+  Boolean $param = false
+) {
+```
+
+When using Puppet 3, data types can be specified in the manifest documentation
+rather than the parameter list, like this:
 
 ```puppet
 # $param::        Some documentation for param
-                  type:boolean
+                  type:Array[String]
 ```
 
-Supported types are: string, boolean, integer, array, password, hash
+For compatibility with older Kafo releases, additional types are supported:
+string, boolean, integer, array, password, hash. These are equivalent to their
+Puppet 4 namesakes, plus wrapped in `Optional[..]` to permit `undef`.
+
+If the data type is given in both the manifest documentation and the parameter
+list, then the manifest documentation will be preferred.
 
 Note that all arguments that are nil (have no value in answers.yaml or you
 set them UNDEF (see below)) are translated to ```undef``` in puppet.
 
+If your module declares its own types, you can add new corresponding subclasses
+of DataType which implement validation and typecasting. This can be added to a
+`boot` hook by calling:
+
+    Kafo::DataType.register_type('YourType', Kafo::DataType::YourType)
+
 ## Password arguments
 
 Kafo supports password arguments. It's adding some level of protection for your
@@ -704,6 +729,10 @@ you must follow a few rules however:
 These functions are re-implemented in Kafo from common stdlib functions, so please
 contribute any missing ones.
 
+If class parameters are declared with Puppet 4 data types then Kafo will
+validate user inputs against Puppet's type validation rules, which should
+replace the use of separate validation functions.
+
 ## Enabling or disabling module
 
 You can enable or disable a module specified in the answers.yaml file. Every module

data/lib/kafo/data_type.rb

@@ -0,0 +1,100 @@
+module Kafo
+  class DataType
+    def self.new_from_string(str)
+      keyword_re = /\A([\w:]+)(?:\[(.*)\])?\z/m.match(str)
+      if keyword_re
+        if (type = @keywords[keyword_re[1]])
+          args = if keyword_re[2]
+                   hash_re = keyword_re[2].match(/\A\s*{(.*)}\s*\z/m)
+                   if hash_re
+                     [parse_hash(hash_re[1])]
+                   else
+                     split_arguments(keyword_re[2])
+                   end
+                 else
+                   []
+                 end
+          type.new(*args)
+        elsif ['Data'].include?(keyword_re[1])
+          DataTypes::Any.new
+        elsif keyword_re[1] == 'Default'
+          DataTypes::Enum.new('default')
+        elsif @keywords[keyword_re[1].capitalize]  # pre-Puppet 4 data types
+          DataTypes::Optional.new(keyword_re[1].capitalize)
+        else
+          raise ConfigurationException, "unknown data type #{keyword_re[1]}"
+        end
+      else
+        raise ConfigurationException, "data type not recognized #{str}"
+      end
+    end
+
+    def self.register_type(keyword, type)
+      @keywords ||= {}
+      raise ArgumentError, "Data type #{keyword} is already registered, cannot be re-registered" if @keywords.has_key?(keyword)
+      @keywords[keyword] = type
+    end
+
+    def self.types
+      @keywords ? @keywords.keys : []
+    end
+
+    def self.unregister_type(keyword)
+      @keywords.delete(keyword) if @keywords
+    end
+
+    def self.split_arguments(input)
+      input.scan(%r{\s*["'/]?([\w:]+(?:\[.+\])?|.+?)["'/]?\s*(?:,|$)}m).flatten
+    end
+
+    def self.parse_hash(input)
+      Hash[input.scan(%r{\s*["'/]?([\w:]+(?:\[[^\]]+\])?|.+?)["'/]?\s*=>\s*["'/]?([\w:]+(?:\[[^\]]+\])?|.+?)["'/]?\s*(?:,|$)}m)]
+    end
+
+    # public interface
+
+    def condition_value(value)
+      value.inspect
+    end
+
+    def dump_default(value)
+      %{"#{value}"}
+    end
+
+    def multivalued?
+      false
+    end
+
+    def to_s
+      self.class.name.split('::').last.downcase
+    end
+
+    def typecast(value)
+      value == 'UNDEF' ? nil : value
+    end
+
+    def valid?(value, errors = [])
+      true
+    end
+  end
+end
+
+require 'kafo/data_types/any'
+require 'kafo/data_types/array'
+require 'kafo/data_types/boolean'
+require 'kafo/data_types/enum'
+require 'kafo/data_types/float'
+require 'kafo/data_types/hash'
+require 'kafo/data_types/integer'
+require 'kafo/data_types/not_undef'
+require 'kafo/data_types/numeric'
+require 'kafo/data_types/optional'
+require 'kafo/data_types/pattern'
+require 'kafo/data_types/regexp'
+require 'kafo/data_types/scalar'
+require 'kafo/data_types/string'
+require 'kafo/data_types/struct'
+require 'kafo/data_types/tuple'
+require 'kafo/data_types/type_reference'
+require 'kafo/data_types/undef'
+require 'kafo/data_types/variant'

data/lib/kafo/data_types/any.rb

@@ -0,0 +1,8 @@
+module Kafo
+  module DataTypes
+    class Any < DataType
+    end
+
+    DataType.register_type('Any', Any)
+  end
+end

data/lib/kafo/data_types/array.rb

@@ -0,0 +1,62 @@
+module Kafo
+  module DataTypes
+    class Array < DataType
+      def initialize(inner_type = 'Data', min = :default, max = :default)
+        @inner_type = DataType.new_from_string(inner_type)
+        @min = (min.to_s == 'default') ? 0 : min.to_i
+        @max = (max.to_s == 'default') ? :infinite : max.to_i
+      end
+
+      def condition_value(value)
+        "[ #{value.map { |v| @inner_type.condition_value(v) }.join(', ')} ]"
+      end
+
+      def multivalued?
+        true
+      end
+
+      def to_s
+        type = "array of #{@inner_type}"
+        if @min > 0 && @max == :infinite
+          "#{type} (at least #{@min} items)"
+        elsif @min == 0 && @max != :infinite
+          "#{type} (up to #{@max} items)"
+        elsif @min > 0 && @max != :infinite
+          "#{type} (between #{@min} and #{@max} items)"
+        else
+          type
+        end
+      end
+
+      def typecast(value)
+        if value.nil?
+          nil
+        elsif value == ['EMPTY_ARRAY']
+          []
+        else
+          [value].flatten.map { |v| @inner_type.typecast(v) }
+        end
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::Array)
+          errors << "#{input.inspect} is not a valid array"
+          return false
+        end
+
+        inner_errors = []
+        input.each { |v| @inner_type.valid?(v, inner_errors) }
+        unless inner_errors.empty?
+          errors << "Elements of the array are invalid: #{inner_errors.join(', ')}"
+        end
+
+        errors << "The array must have at least #{@min} items" if input.size < @min
+        errors << "The array must have at maximum #{@max} items" if @max != :infinite && input.size > @max
+
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Array', Array)
+  end
+end

data/lib/kafo/data_types/boolean.rb

@@ -0,0 +1,24 @@
+module Kafo
+  module DataTypes
+    class Boolean < DataType
+      def typecast(value)
+        case value
+          when '0', 'false', 'f', 'n', false
+            false
+          when '1', 'true', 't', 'y', true
+            true
+          else
+            value
+        end
+      end
+
+      def valid?(input, errors = [])
+        (input.is_a?(::TrueClass) || input.is_a?(::FalseClass)).tap do |valid|
+          errors << "#{input.inspect} is not a valid boolean" unless valid
+        end
+      end
+    end
+
+    DataType.register_type('Boolean', Boolean)
+  end
+end

data/lib/kafo/data_types/enum.rb

@@ -0,0 +1,25 @@
+module Kafo
+  module DataTypes
+    class Enum < DataType
+      def initialize(*permitted)
+        @permitted = permitted
+      end
+
+      def to_s
+        @permitted.map(&:inspect).join(' or ')
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::String)
+          errors << "#{input.inspect} is not a valid string"
+          return false
+        end
+
+        errors << "#{input} must be one of #{@permitted.join(', ')}" unless @permitted.include?(input)
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Enum', Enum)
+  end
+end

data/lib/kafo/data_types/float.rb

@@ -0,0 +1,40 @@
+module Kafo
+  module DataTypes
+    class Float < DataType
+      def initialize(min = :default, max = :default)
+        @min = (min.to_s == 'default') ? :infinite : min.to_i
+        @max = (max.to_s == 'default') ? :infinite : max.to_i
+      end
+
+      def to_s
+        if @min != :infinite && @max == :infinite
+          "float (at least #{@min})"
+        elsif @min == :infinite && @max != :infinite
+          "float (up to #{@max})"
+        elsif @min != :infinite && @max != :infinite
+          "float (between #{@min} and #{@max})"
+        else
+          "float"
+        end
+      end
+
+      def typecast(value)
+        value.to_s =~ /\d+/ ? value.to_f : value
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::Float)
+          errors << "#{input.inspect} is not a valid float"
+          return false
+        end
+
+        errors << "#{input} must be at least #{@min}" if @min != :infinite && input < @min
+        errors << "#{input} must be up to #{@max}" if @max != :infinite && input > @max
+
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Float', Float)
+  end
+end

data/lib/kafo/data_types/hash.rb

@@ -0,0 +1,70 @@
+module Kafo
+  module DataTypes
+    class Hash < DataType
+      def initialize(inner_key_type = 'Scalar', inner_value_type = 'Data', min = :default, max = :default)
+        @inner_key_type = DataType.new_from_string(inner_key_type)
+        @inner_value_type = DataType.new_from_string(inner_value_type)
+        @min = (min.to_s == 'default') ? 0 : min.to_i
+        @max = (max.to_s == 'default') ? :infinite : max.to_i
+      end
+
+      def multivalued?
+        true
+      end
+
+      def to_s
+        type = "hash of #{@inner_key_type}/#{@inner_value_type}"
+        if @min > 0 && @max == :infinite
+          "#{type} (at least #{@min} items)"
+        elsif @min == 0 && @max != :infinite
+          "#{type} (up to #{@max} items)"
+        elsif @min > 0 && @max != :infinite
+          "#{type} (between #{@min} and #{@max} items)"
+        else
+          type
+        end
+      end
+
+      def typecast(value)
+        if value.nil?
+          nil
+        elsif value.is_a?(::Hash)
+          value
+        elsif value == ['EMPTY_HASH']
+          {}
+        else
+          ::Hash[[value].flatten.map do |kv|
+            k, v = kv.split(':', 2)
+            [@inner_key_type.typecast(k), @inner_value_type.typecast(v)]
+          end]
+        end
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::Hash)
+          errors << "#{input.inspect} is not a valid hash"
+          return false
+        end
+
+        inner_key_errors = []
+        input.keys.each { |v| @inner_key_type.valid?(v, inner_key_errors) }
+        unless inner_key_errors.empty?
+          errors << "Hash key elements are invalid: #{inner_key_errors.join(', ')}"
+        end
+
+        inner_value_errors = []
+        input.values.each { |v| @inner_value_type.valid?(v, inner_value_errors) }
+        unless inner_value_errors.empty?
+          errors << "Hash value elements are invalid: #{inner_value_errors.join(', ')}"
+        end
+
+        errors << "The hash must have at least #{@min} items" if input.size < @min
+        errors << "The hash must have at maximum #{@max} items" if @max != :infinite && input.size > @max
+
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Hash', Hash)
+  end
+end

data/lib/kafo/data_types/integer.rb

@@ -0,0 +1,40 @@
+module Kafo
+  module DataTypes
+    class Integer < DataType
+      def initialize(min = :default, max = :default)
+        @min = (min.to_s == 'default') ? :infinite : min.to_i
+        @max = (max.to_s == 'default') ? :infinite : max.to_i
+      end
+
+      def to_s
+        if @min != :infinite && @max == :infinite
+          "integer (at least #{@min})"
+        elsif @min == :infinite && @max != :infinite
+          "integer (up to #{@max})"
+        elsif @min != :infinite && @max != :infinite
+          "integer (between #{@min} and #{@max})"
+        else
+          "integer"
+        end
+      end
+
+      def typecast(value)
+        value =~ /\d+/ ? value.to_i : value
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::Integer)
+          errors << "#{input.inspect} is not a valid integer"
+          return false
+        end
+
+        errors << "#{input} must be at least #{@min}" if @min != :infinite && input < @min
+        errors << "#{input} must be up to #{@max}" if @max != :infinite && input > @max
+
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Integer', Integer)
+  end
+end

data/lib/kafo/data_types/not_undef.rb

@@ -0,0 +1,34 @@
+module Kafo
+  module DataTypes
+    class NotUndef < DataType
+      extend Forwardable
+      def_delegators :@inner_type, :condition_value, :dump_default, :multivalued?, :typecast
+      attr_reader :inner_type, :inner_value
+
+      def initialize(inner_type_or_value)
+        begin
+          @inner_type = DataType.new_from_string(inner_type_or_value)
+        rescue ConfigurationException
+          @inner_value = inner_type_or_value
+        end
+      end
+
+      def to_s
+        if @inner_type
+          "#{@inner_type} but not undef"
+        else
+          "#{@inner_value.inspect} but not undef"
+        end
+      end
+
+      def valid?(input, errors = [])
+        return false if input.nil?
+        return true if @inner_type && @inner_type.valid?(input, errors)
+        return true if @inner_value && @inner_value == input
+        return false
+      end
+    end
+
+    DataType.register_type('NotUndef', NotUndef)
+  end
+end

data/lib/kafo/data_types/numeric.rb

@@ -0,0 +1,16 @@
+module Kafo
+  module DataTypes
+    class Numeric < DataType
+      def typecast(value)
+        value =~ /\d+/ ? value.to_f : value
+      end
+
+      def valid?(input, errors = [])
+        errors << "#{input.inspect} is not a valid number" unless input.is_a?(::Integer) || input.is_a?(::Float)
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Numeric', Numeric)
+  end
+end

data/lib/kafo/data_types/optional.rb

@@ -0,0 +1,34 @@
+module Kafo
+  module DataTypes
+    class Optional < DataType
+      extend Forwardable
+      def_delegators :@inner_type, :condition_value, :dump_default, :multivalued?, :typecast
+      attr_reader :inner_type, :inner_value
+
+      def initialize(inner_type_or_value)
+        begin
+          @inner_type = DataType.new_from_string(inner_type_or_value)
+        rescue ConfigurationException
+          @inner_value = inner_type_or_value
+        end
+      end
+
+      def to_s
+        if @inner_type
+          "#{@inner_type} or undef"
+        else
+          "#{@inner_value.inspect} or undef"
+        end
+      end
+
+      def valid?(input, errors = [])
+        return true if input.nil?
+        return true if @inner_type && @inner_type.valid?(input, errors)
+        return true if @inner_value && @inner_value == input
+        return false
+      end
+    end
+
+    DataType.register_type('Optional', Optional)
+  end
+end

data/lib/kafo/data_types/pattern.rb

@@ -0,0 +1,29 @@
+module Kafo
+  module DataTypes
+    class Pattern < DataType
+      def initialize(*regexes)
+        @regex_strings = regexes
+        @regexes = regexes.map { |r| ::Regexp.new(r) }
+      end
+
+      def to_s
+        "regexes matching #{@regex_strings.map { |r| "/#{r}/" }.join(' or ')}"
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::String)
+          errors << "#{input.inspect} is not a valid string"
+          return false
+        end
+
+        unless @regexes.any? { |r| r.match(input) }
+          errors << "#{input} must match one of #{@regexes.join(', ')}"
+        end
+
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Pattern', Pattern)
+  end
+end

data/lib/kafo/data_types/regexp.rb

@@ -0,0 +1,14 @@
+module Kafo
+  module DataTypes
+    class Regexp < DataType
+      extend Forwardable
+      def_delegators :@inner_type, :condition_value, :dump_default, :multivalued?, :typecast, :valid?
+
+      def initialize
+        @inner_type = DataTypes::String.new
+      end
+    end
+
+    DataType.register_type('Regexp', Regexp)
+  end
+end

data/lib/kafo/data_types/scalar.rb

@@ -0,0 +1,14 @@
+module Kafo
+  module DataTypes
+    class Scalar < DataType
+      extend Forwardable
+      def_delegators :@inner_type, :condition_value, :dump_default, :multivalued?, :typecast, :valid?
+
+      def initialize
+        @inner_type = DataTypes::Variant.new('Integer', 'Float', 'String', 'Boolean', 'Regexp')
+      end
+    end
+
+    DataType.register_type('Scalar', Scalar)
+  end
+end

data/lib/kafo/data_types/string.rb

@@ -0,0 +1,36 @@
+module Kafo
+  module DataTypes
+    class String < DataType
+      def initialize(min = :default, max = :default)
+        @min = (min.to_s == 'default') ? 0 : min.to_i
+        @max = (max.to_s == 'default') ? :infinite : max.to_i
+      end
+
+      def to_s
+        if @min > 0 && @max == :infinite
+          "string (at least #{@min} characters)"
+        elsif @min == 0 && @max != :infinite
+          "string (up to #{@max} characters)"
+        elsif @min > 0 && @max != :infinite
+          "string (between #{@min} and #{@max} characters)"
+        else
+          "string"
+        end
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::String)
+          errors << "#{input.inspect} is not a valid string"
+          return false
+        end
+
+        errors << "#{input} must be at least #{@min}" if input.size < @min
+        errors << "#{input} must be up to #{@max}" if @max != :infinite && input.size > @max
+
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('String', String)
+  end
+end

data/lib/kafo/data_types/struct.rb

@@ -0,0 +1,100 @@
+module Kafo
+  module DataTypes
+    class Struct < DataType
+      def initialize(spec)
+        @spec = ::Hash[spec.map do |k,v|
+          begin
+            k = DataType.new_from_string(k)
+          rescue ConfigurationException; end
+          begin
+            v = DataType.new_from_string(v)
+          rescue ConfigurationException; end
+          [k, v]
+        end]
+      end
+
+      def multivalued?
+        true
+      end
+
+      def to_s
+        "struct containing " + @spec.keys.map do |k|
+          if k.is_a?(Optional)
+            [k.inner_value, %{"#{k.inner_value}" (optional #{@spec[k]})}]
+          elsif k.is_a?(NotUndef)
+            [k.inner_value, %{"#{k.inner_value}" (required #{@spec[k]})}]
+          else
+            [k, %{"#{k}" (#{@spec[k]})}]
+          end
+        end.sort_by(&:first).map(&:last).join(', ')
+      end
+
+      def typecast(value)
+        if value.nil?
+          nil
+        elsif value.is_a?(::Hash)
+          value
+        elsif value == ['EMPTY_HASH']
+          {}
+        else
+          ::Hash[[value].flatten.map do |kv|
+            k, v = kv.split(':', 2)
+            if (value_type = spec_value(k))
+              [k, value_type.typecast(v)]
+            else
+              [k, v]
+            end
+          end]
+        end
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::Hash)
+          errors << "#{input.inspect} is not a valid struct"
+          return false
+        end
+
+        required_keys = @spec.keys.select { |k| k.is_a?(NotUndef) }.map { |k| k.inner_value }
+        missing_keys = required_keys - input.keys
+        errors << "Struct elements are missing: #{missing_keys.join(', ')}" unless missing_keys.empty?
+
+        known_keys = @spec.keys.map { |k| spec_key_name(k) }
+        extra_keys = input.keys - known_keys
+        errors << "Struct elements are not permitted: #{extra_keys.join(', ')}" unless extra_keys.empty?
+
+        value_errors = []
+
+        # Only check values for optional keys if present
+        optional_keys = @spec.keys.select { |k| k.is_a?(Optional) }.map { |k| k.inner_value }
+        (optional_keys & input.keys).each { |k| spec_value(k).valid?(input[k], value_errors) }
+
+        # For non-optional and non-required keys, assume nil/undef values if absent
+        regular_keys = @spec.keys.select { |k| !k.is_a?(Optional) }.map { |k| spec_key_name(k) }
+        regular_keys.each { |k| spec_value(k).valid?(input[k], value_errors) }
+
+        errors << "Struct values are invalid: #{value_errors.join(', ')}" unless value_errors.empty?
+
+        return errors.empty?
+      end
+
+      private
+
+      def spec_value(key)
+        spec_entry = @spec.find do |k,v|
+          spec_key_name(k) == key
+        end
+        spec_entry ? spec_entry.last : nil
+      end
+
+      def spec_key_name(key)
+        if key.is_a?(Optional) || key.is_a?(NotUndef)
+          key.inner_value
+        else
+          key
+        end
+      end
+    end
+
+    DataType.register_type('Struct', Struct)
+  end
+end

data/lib/kafo/data_types/tuple.rb

@@ -0,0 +1,76 @@
+module Kafo
+  module DataTypes
+    class Tuple < DataType
+      def initialize(*args)
+        if args.last.to_s =~ /\d+/ || args.last.to_s == 'default'
+          max = args.pop
+          min = args.pop
+        else
+          max = :default
+          min = :default
+        end
+        @max = (max.to_s == 'default') ? :infinite : max.to_i
+        @min = (min.to_s == 'default') ? 0 : min.to_i
+        @inner_types = args.map { |type| DataType.new_from_string(type) }
+      end
+
+      def condition_value(value)
+        "[ #{value.each_with_index.map { |v,i| inner_types(value)[i].condition_value(v) }.join(', ')} ]"
+      end
+
+      def multivalued?
+        true
+      end
+
+      def to_s
+        type = "tuple of #{@inner_types.join(', ')}"
+        if @min > 0 && @max == :infinite
+          "#{type} (at least #{@min} items)"
+        elsif @min == 0 && @max != :infinite
+          "#{type} (up to #{@max} items)"
+        elsif @min > 0 && @max != :infinite
+          "#{type} (between #{@min} and #{@max} items)"
+        else
+          type
+        end
+      end
+
+      def typecast(value)
+        if value.nil?
+          nil
+        elsif value == ['EMPTY_ARRAY']
+          []
+        else
+          values = [value].flatten
+          values.each_with_index.map { |v,i| inner_types(values)[i].typecast(v) }
+        end
+      end
+
+      def valid?(input, errors = [])
+        unless input.is_a?(::Array)
+          errors << "#{input.inspect} is not a valid tuple"
+          return false
+        end
+
+        inner_errors = []
+        input.each_with_index { |v,i| inner_types(input)[i].valid?(v, inner_errors) }
+        unless inner_errors.empty?
+          errors << "Elements of the tuple are invalid: #{inner_errors.join(', ')}"
+        end
+
+        errors << "The tuple must have at least #{@min} items" if input.size < @min
+        errors << "The tuple must have at maximum #{@max} items" if @max != :infinite && input.size > @max
+
+        return errors.empty?
+      end
+
+      private
+
+      def inner_types(value)
+        @inner_types + ([@inner_types.last] * (value.size - @inner_types.size))
+      end
+    end
+
+    DataType.register_type('Tuple', Tuple)
+  end
+end

data/lib/kafo/data_types/type_reference.rb

@@ -0,0 +1,14 @@
+module Kafo
+  module DataTypes
+    class TypeReference < DataType
+      extend Forwardable
+      def_delegators :@inner_type, :condition_value, :dump_default, :multivalued?, :to_s, :typecast, :valid?
+
+      def initialize(inner_type)
+        @inner_type = DataType.new_from_string(inner_type)
+      end
+    end
+
+    DataType.register_type('TypeReference', TypeReference)
+  end
+end

data/lib/kafo/data_types/undef.rb

@@ -0,0 +1,12 @@
+module Kafo
+  module DataTypes
+    class Undef < DataType
+      def valid?(input, errors = [])
+        errors << "#{input} must be undef" unless input.nil?
+        return errors.empty?
+      end
+    end
+
+    DataType.register_type('Undef', Undef)
+  end
+end

data/lib/kafo/data_types/variant.rb

@@ -0,0 +1,50 @@
+module Kafo
+  module DataTypes
+    class Variant < DataType
+      def initialize(*inner_types)
+        @inner_types = inner_types.map { |t| DataType.new_from_string(t) }
+      end
+
+      def condition_value(value)
+        type = find_type(value)
+        type ? type.condition_value(value) : super(value)
+      end
+
+      def dump_default(value)
+        type = find_type(value)
+        type ? type.dump_default(value) : super(value)
+      end
+
+      def multivalued?
+        @inner_types.any? { |t| t.multivalued? }
+      end
+
+      def to_s
+        @inner_types.join(' or ')
+      end
+
+      def typecast(value)
+        type = find_type(value)
+        type ? type.typecast(value) : value
+      end
+
+      def valid?(value, errors = [])
+        type = find_type(value)
+        if type
+          type.valid?(value, errors)
+        else
+          errors << "#{value} is not one of #{to_s}"
+          false
+        end
+      end
+
+      private
+
+      def find_type(value)
+        @inner_types.find { |t| t.valid?(t.typecast(value)) }
+      end
+    end
+
+    DataType.register_type('Variant', Variant)
+  end
+end

data/lib/kafo/hook_context.rb

@@ -1,3 +1,5 @@
+require 'kafo/data_type'
+
 module Kafo
   class HookContext
     attr_reader :kafo

data/lib/kafo/kafo_configure.rb

@@ -197,10 +197,6 @@ module Kafo
       self.class.exit(:unknown_module)
     end
 
-    def enabled_params
-      params.select { |p| p.module.enabled? }
-    end
-
     def reset_params_cache
       @params = nil
       params
@@ -395,7 +391,7 @@ module Kafo
 
     def validate_all(logging = true)
       logger.info 'Running validation checks'
-      results = enabled_params.map do |param|
+      results = params.map do |param|
         result = param.valid?
         errors = param.validation_errors.join(', ')
         progress_log(:error, "Parameter #{with_prefix(param)} invalid: #{errors}") if logging && !result

data/lib/kafo/param.rb

@@ -1,15 +1,17 @@
 # encoding: UTF-8
 require 'kafo/condition'
+require 'kafo/validator'
 
 module Kafo
   class Param
-    attr_reader :name, :module
+    attr_reader :name, :module, :type
     attr_accessor :default, :doc, :value_set, :condition
     attr_writer :groups
 
-    def initialize(builder, name)
+    def initialize(builder, name, type)
       @name   = name
       @module = builder
+      @type   = DataType.new_from_string(type)
     end
 
     def groups
@@ -18,12 +20,13 @@ module Kafo
 
     # we use @value_set flag because even nil can be valid value
     def value
-      @value_set ? @value : default
+      @value_set ? @type.typecast(@value) : default
     end
 
     def value=(value)
       @value_set = true
-      @value     = value == 'UNDEF' ? nil : normalize_value(value)
+      value      = value.to_s if value.is_a?(::HighLine::String)  # don't persist highline extensions
+      @value     = value
     end
 
     def unset_value
@@ -32,7 +35,7 @@ module Kafo
     end
 
     def dump_default
-      default
+      @type.dump_default(default)
     end
 
     def module_name
@@ -40,7 +43,7 @@ module Kafo
     end
 
     def to_s
-      "#<#{self.class}:#{self.object_id} @name=#{name.inspect} @default=#{default.inspect} @value=#{value.inspect}>"
+      "#<#{self.class}:#{self.object_id} @name=#{name.inspect} @default=#{default.inspect} @value=#{value.inspect} @type=#{@type}>"
     end
 
     def set_default(defaults)
@@ -86,22 +89,23 @@ module Kafo
         {:name => v.name, :arguments => interpret_validation_args(args)}
       end
 
+      # run old style validation functions
       @validator = Validator.new
       validations.each { |v| @validator.send(v[:name], v[:arguments]) }
-      @validator.errors.empty?
+      @validation_errors = @validator.errors.dup
+
+      # run data type based validations, append errors
+      @type.valid?(value, @validation_errors)
+
+      @validation_errors.empty?
     end
 
     def validation_errors
-      if @validator
-        @validator.errors
-      else
-        []
-      end
+      @validation_errors || []
     end
 
-    # To be overwritten in children
     def multivalued?
-      false
+      @type.multivalued?
     end
 
     def <=> o
@@ -117,7 +121,7 @@ module Kafo
     end
 
     def condition_value
-      value.to_s
+      @type.condition_value(value)
     end
 
     private
@@ -139,25 +143,7 @@ module Kafo
         arg == :undef ? nil : arg
       end
     end
-
-    def normalize_value(value)
-      case value
-        when ::HighLine::String  # don't persist highline extensions
-          value.to_s
-        when Array
-          value.map { |v| normalize_value(v) }
-        when Hash
-          Hash[value.map { |k,v| [normalize_value(k), normalize_value(v)] }]
-        else
-          value
-      end
-    end
   end
 end
 
-require 'kafo/params/boolean'
-require 'kafo/params/string'
 require 'kafo/params/password'
-require 'kafo/params/array'
-require 'kafo/params/hash'
-require 'kafo/params/integer'

data/lib/kafo/param_builder.rb

@@ -52,7 +52,14 @@ module Kafo
     end
 
     def build(name, data)
-      param           = get_type(data[:types][name]).new(@module, name)
+      data_type = data[:types][name] || 'Data'
+      if data_type == 'password'
+        type = Params::Password
+        data_type = 'String'
+      else
+        type = Param
+      end
+      param           = type.new(@module, name, data_type)
       param.default   = data[:values][name]
       param.doc       = data[:docs][name]
       param.groups    = data[:groups][name]
@@ -77,10 +84,5 @@ module Kafo
       end
       param_group
     end
-
-    def get_type(type)
-      type = (type || 'string').capitalize
-      Params.const_defined?(type) ? Params.const_get(type) : raise(TypeError, "undefined parameter type '#{type}'")
-    end
   end
 end

data/lib/kafo/params/password.rb

@@ -19,14 +19,6 @@ module Kafo
         @encrypted
       end
 
-      def condition_value
-        %{"#{value}"}
-      end
-
-      def dump_default
-        %{"#{super}"}
-      end
-
       private
 
       def setup_password

data/lib/kafo/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 module Kafo
   PARSER_CACHE_VERSION = 1
-  VERSION = "0.9.8"
+  VERSION = "1.0.0"
 end

data/lib/kafo/wizard.rb

@@ -124,6 +124,7 @@ END
     def configure(param)
       say "\n" + HighLine.color("Parameter #{param.name} (of module #{param.module.name})", :headline)
       say HighLine.color(param.doc.join("\n").gsub('"', '\"'), :important)
+      say HighLine.color("Data type: #{param.type}", :important)
       value       = param.multivalued? ? configure_multi(param) : configure_single(param)
       value_was   = param.value
       param.value = value unless value.empty?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kafo
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Marek Hulan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2016-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -220,6 +220,26 @@ files:
 - lib/kafo/color_scheme.rb
 - lib/kafo/condition.rb
 - lib/kafo/configuration.rb
+- lib/kafo/data_type.rb
+- lib/kafo/data_types/any.rb
+- lib/kafo/data_types/array.rb
+- lib/kafo/data_types/boolean.rb
+- lib/kafo/data_types/enum.rb
+- lib/kafo/data_types/float.rb
+- lib/kafo/data_types/hash.rb
+- lib/kafo/data_types/integer.rb
+- lib/kafo/data_types/not_undef.rb
+- lib/kafo/data_types/numeric.rb
+- lib/kafo/data_types/optional.rb
+- lib/kafo/data_types/pattern.rb
+- lib/kafo/data_types/regexp.rb
+- lib/kafo/data_types/scalar.rb
+- lib/kafo/data_types/string.rb
+- lib/kafo/data_types/struct.rb
+- lib/kafo/data_types/tuple.rb
+- lib/kafo/data_types/type_reference.rb
+- lib/kafo/data_types/undef.rb
+- lib/kafo/data_types/variant.rb
 - lib/kafo/exceptions.rb
 - lib/kafo/exit_handler.rb
 - lib/kafo/help_builder.rb
@@ -236,12 +256,7 @@ files:
 - lib/kafo/param.rb
 - lib/kafo/param_builder.rb
 - lib/kafo/param_group.rb
-- lib/kafo/params/array.rb
-- lib/kafo/params/boolean.rb
-- lib/kafo/params/hash.rb
-- lib/kafo/params/integer.rb
 - lib/kafo/params/password.rb
-- lib/kafo/params/string.rb
 - lib/kafo/parser_cache_reader.rb
 - lib/kafo/parser_cache_writer.rb
 - lib/kafo/password_manager.rb

data/lib/kafo/params/array.rb

@@ -1,28 +0,0 @@
-module Kafo
-  module Params
-    class Array < Param
-      def value=(value)
-        super
-        if @value == ['EMPTY_ARRAY']
-          @value = []
-        else
-          @value = typecast(@value)
-        end
-      end
-
-      def multivalued?
-        true
-      end
-
-      def condition_value
-        "[ #{value.map(&:inspect).join(', ')} ]"
-      end
-
-      private
-
-      def typecast(value)
-        value.nil? ? nil : [value].flatten
-      end
-    end
-  end
-end

data/lib/kafo/params/boolean.rb

@@ -1,27 +0,0 @@
-module Kafo
-  module Params
-    class Boolean < Param
-      def value=(value)
-        super
-        @value = typecast(@value)
-      end
-
-      def dump_default
-        %{"#{super}"}
-      end
-
-      private
-
-      def typecast(value)
-        case value
-          when '0', 'false', 'f', 'n', false
-            false
-          when '1', 'true', 't', 'y', true
-            true
-          else
-            value
-        end
-      end
-    end
-  end
-end

data/lib/kafo/params/hash.rb

@@ -1,38 +0,0 @@
-module Kafo
-  module Params
-    class Hash < Param
-      def value=(value)
-        super
-        if @value == ['EMPTY_HASH']
-          @value = {}
-        else
-          @value = typecast(@value)
-        end
-      end
-
-      def multivalued?
-        true
-      end
-
-      def condition_value
-        value.inspect
-      end
-
-      private
-
-      def typecast(value)
-        if value.nil?
-          nil
-        elsif value.is_a?(::Hash)
-          value
-        else
-          value = [value].flatten
-          ::Hash[value.map { |v| v.split(':', 2) }]
-        end
-      rescue NoMethodError => e
-        KafoConfigure.logger.warn "Could not typecast #{value} for parameter #{name}, defaulting to {}"
-        return {}
-      end
-    end
-  end
-end

data/lib/kafo/params/integer.rb

@@ -1,19 +0,0 @@
-module Kafo
-  module Params
-    class Integer < Param
-      def value=(value)
-        super
-        @value = typecast(@value)
-      end
-
-      private
-
-      def typecast(value)
-        value.nil? ? nil : value.to_i
-      rescue NoMethodError => e
-        KafoConfigure.logger.warn "Could not typecast #{value} for parameter #{name}, defaulting to 0"
-        return 0
-      end
-    end
-  end
-end

data/lib/kafo/params/string.rb

@@ -1,13 +0,0 @@
-module Kafo
-  module Params
-    class String < Param
-      def condition_value
-        %{"#{value}"}
-      end
-
-      def dump_default
-        %{"#{super}"}
-      end
-    end
-  end
-end