diff options
Diffstat (limited to 'lib/puppet/parameter.rb')
| -rw-r--r-- | lib/puppet/parameter.rb | 211 |
1 files changed, 1 insertions, 210 deletions
diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb index 58a91477a..0e4071cc5 100644 --- a/lib/puppet/parameter.rb +++ b/lib/puppet/parameter.rb @@ -12,216 +12,7 @@ class Puppet::Parameter include Puppet::Util::MethodHelper include Puppet::Util::Cacher - # A collection of values and regexes, used for specifying - # what values are allowed in a given parameter. - class ValueCollection - class Value - attr_reader :name, :options, :event - attr_accessor :block, :call, :method, :required_features - - # Add an alias for this value. - def alias(name) - @aliases << convert(name) - end - - # Return all aliases. - def aliases - @aliases.dup - end - - # Store the event that our value generates, if it does so. - def event=(value) - @event = convert(value) - end - - def initialize(name) - if name.is_a?(Regexp) - @name = name - else - # Convert to a string and then a symbol, so things like true/false - # still show up as symbols. - @name = convert(name) - end - - @aliases = [] - - @call = :instead - end - - # Does a provided value match our value? - def match?(value) - if regex? - return true if name =~ value.to_s - else - return true if name == convert(value) - return @aliases.include?(convert(value)) - end - end - - # Is our value a regex? - def regex? - @name.is_a?(Regexp) - end - - private - - # A standard way of converting all of our values, so we're always - # comparing apples to apples. - def convert(value) - if value == '' - # We can't intern an empty string, yay. - value - else - value.to_s.to_sym - end - end - end - - def aliasvalue(name, other) - other = other.to_sym - unless value = match?(other) - raise Puppet::DevError, "Cannot alias nonexistent value %s" % other - end - - value.alias(name) - end - - # Return a doc string for all of the values in this parameter/property. - def doc - unless defined?(@doc) - @doc = "" - unless values.empty? - @doc += " Valid values are " - @doc += @strings.collect do |value| - if aliases = value.aliases and ! aliases.empty? - "``%s`` (also called ``%s``)" % [value.name, aliases.join(", ")] - else - "``%s``" % value.name - end - end.join(", ") + "." - end - - unless regexes.empty? - @doc += " Values can match ``" + regexes.join("``, ``") + "``." - end - end - - @doc - end - - # Does this collection contain any value definitions? - def empty? - @values.empty? - end - - def initialize - # We often look values up by name, so a hash makes more sense. - @values = {} - - # However, we want to retain the ability to match values in order, - # but we always prefer directly equality (i.e., strings) over regex matches. - @regexes = [] - @strings = [] - end - - # Can we match a given value? - def match?(test_value) - # First look for normal values - if value = @strings.find { |v| v.match?(test_value) } - return value - end - - # Then look for a regex match - @regexes.find { |v| v.match?(test_value) } - end - - # If the specified value is allowed, then munge appropriately. - def munge(value) - return value if empty? - - if instance = match?(value) - if instance.regex? - return value - else - return instance.name - end - else - return value - end - end - - # Define a new valid value for a property. You must provide the value itself, - # usually as a symbol, or a regex to match the value. - # - # The first argument to the method is either the value itself or a regex. - # The second argument is an option hash; valid options are: - # * <tt>:event</tt>: The event that should be returned when this value is set. - # * <tt>:call</tt>: When to call any associated block. The default value - # is ``instead``, which means to call the value instead of calling the - # provider. You can also specify ``before`` or ``after``, which will - # call both the block and the provider, according to the order you specify - # (the ``first`` refers to when the block is called, not the provider). - def newvalue(name, options = {}, &block) - value = Value.new(name) - @values[value.name] = value - if value.regex? - @regexes << value - else - @strings << value - end - - options.each { |opt, arg| value.send(opt.to_s + "=", arg) } - if block_given? - value.block = block - else - value.call = options[:call] || :none - end - - if block_given? and ! value.regex? - value.method ||= "set_" + value.name.to_s - end - - value - end - - # Define one or more new values for our parameter. - def newvalues(*names) - names.each { |name| newvalue(name) } - end - - def regexes - @regexes.collect { |r| r.name.inspect } - end - - # Verify that the passed value is valid. - def validate(value) - return if empty? - - unless @values.detect { |name, v| v.match?(value) } - str = "Invalid value %s. " % [value.inspect] - - unless values.empty? - str += "Valid values are %s. " % values.join(", ") - end - - unless regexes.empty? - str += "Valid values match %s." % regexes.join(", ") - end - - raise ArgumentError, str - end - end - - # Return a single value instance. - def value(name) - @values[name] - end - - # Return the list of valid values. - def values - @strings.collect { |s| s.name } - end - end + require 'puppet/parameter/value_collection' class << self include Puppet::Util |