diff options
| -rw-r--r-- | lib/puppet/parameter.rb | 211 | ||||
| -rw-r--r-- | lib/puppet/parameter/value.rb | 64 | ||||
| -rw-r--r-- | lib/puppet/parameter/value_collection.rb | 151 | ||||
| -rwxr-xr-x | spec/unit/parameter.rb | 244 | ||||
| -rwxr-xr-x | spec/unit/parameter/value.rb | 88 | ||||
| -rwxr-xr-x | spec/unit/parameter/value_collection.rb | 167 |
6 files changed, 471 insertions, 454 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 diff --git a/lib/puppet/parameter/value.rb b/lib/puppet/parameter/value.rb new file mode 100644 index 000000000..5171f2580 --- /dev/null +++ b/lib/puppet/parameter/value.rb @@ -0,0 +1,64 @@ +require 'puppet/parameter/value_collection' + +# An individual Value class. +class Puppet::Parameter::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 diff --git a/lib/puppet/parameter/value_collection.rb b/lib/puppet/parameter/value_collection.rb new file mode 100644 index 000000000..436226ebe --- /dev/null +++ b/lib/puppet/parameter/value_collection.rb @@ -0,0 +1,151 @@ +require 'puppet/parameter/value' + +# A collection of values and regexes, used for specifying +# what values are allowed in a given parameter. +class Puppet::Parameter::ValueCollection + + 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 = Puppet::Parameter::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 diff --git a/spec/unit/parameter.rb b/spec/unit/parameter.rb index e3eaca6ac..817b5c6d6 100755 --- a/spec/unit/parameter.rb +++ b/spec/unit/parameter.rb @@ -159,247 +159,3 @@ describe Puppet::Parameter do end end -describe Puppet::Parameter::ValueCollection do - before do - @collection = Puppet::Parameter::ValueCollection.new - end - - it "should have a method for defining new values" do - @collection.should respond_to(:newvalues) - end - - it "should have a method for adding individual values" do - @collection.should respond_to(:newvalue) - end - - it "should be able to retrieve individual values" do - value = @collection.newvalue(:foo) - @collection.value(:foo).should equal(value) - end - - it "should be able to add an individual value with a block" do - @collection.newvalue(:foo) { raise "testing" } - @collection.value(:foo).block.should be_instance_of(Proc) - end - - it "should be able to add values that are empty strings" do - lambda { @collection.newvalue('') }.should_not raise_error - end - - it "should be able to add values that are empty strings" do - value = @collection.newvalue('') - @collection.match?('').should equal(value) - end - - it "should set :call to :none when adding a value with no block" do - value = @collection.newvalue(:foo) - value.call.should == :none - end - - describe "when adding a value with a block" do - it "should set the method name to 'set_' plus the value name" do - value = @collection.newvalue(:myval) { raise "testing" } - value.method.should == "set_myval" - end - end - - it "should be able to add an individual value with options" do - value = @collection.newvalue(:foo, :call => :bar) - value.call.should == :bar - end - - it "should have a method for validating a value" do - @collection.should respond_to(:validate) - end - - it "should have a method for munging a value" do - @collection.should respond_to(:munge) - end - - it "should be able to generate documentation when it has both values and regexes" do - @collection.newvalues :foo, "bar", %r{test} - @collection.doc.should be_instance_of(String) - end - - it "should correctly generate documentation for values" do - @collection.newvalues :foo - @collection.doc.should be_include("Valid values are ``foo``") - end - - it "should correctly generate documentation for regexes" do - @collection.newvalues %r{\w+} - @collection.doc.should be_include("Values can match ``/\\w+/``") - end - - it "should be able to find the first matching value" do - @collection.newvalues :foo, :bar - @collection.match?("foo").should be_instance_of(Puppet::Parameter::ValueCollection::Value) - end - - it "should be able to match symbols" do - @collection.newvalues :foo, :bar - @collection.match?(:foo).should be_instance_of(Puppet::Parameter::ValueCollection::Value) - end - - it "should be able to match symbols when a regex is provided" do - @collection.newvalues %r{.} - @collection.match?(:foo).should be_instance_of(Puppet::Parameter::ValueCollection::Value) - end - - it "should be able to match values using regexes" do - @collection.newvalues %r{.} - @collection.match?("foo").should_not be_nil - end - - it "should prefer value matches to regex matches" do - @collection.newvalues %r{.}, :foo - @collection.match?("foo").name.should == :foo - end - - describe "when validating values" do - it "should do nothing if no values or regexes have been defined" do - @collection.validate("foo") - end - - it "should fail if the value is not a defined value or alias and does not match a regex" do - @collection.newvalues :foo - lambda { @collection.validate("bar") }.should raise_error(ArgumentError) - end - - it "should succeed if the value is one of the defined values" do - @collection.newvalues :foo - lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError) - end - - it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do - @collection.newvalues :foo - lambda { @collection.validate("foo") }.should_not raise_error(ArgumentError) - end - - it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do - @collection.newvalues "foo" - lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError) - end - - it "should succeed if the value is one of the defined aliases" do - @collection.newvalues :foo - @collection.aliasvalue :bar, :foo - lambda { @collection.validate("bar") }.should_not raise_error(ArgumentError) - end - - it "should succeed if the value matches one of the regexes" do - @collection.newvalues %r{\d} - lambda { @collection.validate("10") }.should_not raise_error(ArgumentError) - end - end - - describe "when munging values" do - it "should do nothing if no values or regexes have been defined" do - @collection.munge("foo").should == "foo" - end - - it "should return return any matching defined values" do - @collection.newvalues :foo, :bar - @collection.munge("foo").should == :foo - end - - it "should return any matching aliases" do - @collection.newvalues :foo - @collection.aliasvalue :bar, :foo - @collection.munge("bar").should == :foo - end - - it "should return the value if it matches a regex" do - @collection.newvalues %r{\w} - @collection.munge("bar").should == "bar" - end - - it "should return the value if no other option is matched" do - @collection.newvalues :foo - @collection.munge("bar").should == "bar" - end - end -end - -describe Puppet::Parameter::ValueCollection::Value do - it "should require a name" do - lambda { Puppet::Parameter::ValueCollection::Value.new }.should raise_error(ArgumentError) - end - - it "should set its name" do - Puppet::Parameter::ValueCollection::Value.new(:foo).name.should == :foo - end - - it "should support regexes as names" do - lambda { Puppet::Parameter::ValueCollection::Value.new(%r{foo}) }.should_not raise_error - end - - it "should mark itself as a regex if its name is a regex" do - Puppet::Parameter::ValueCollection::Value.new(%r{foo}).should be_regex - end - - it "should always convert its name to a symbol if it is not a regex" do - Puppet::Parameter::ValueCollection::Value.new("foo").name.should == :foo - Puppet::Parameter::ValueCollection::Value.new(true).name.should == :true - end - - it "should support adding aliases" do - Puppet::Parameter::ValueCollection::Value.new("foo").should respond_to(:alias) - end - - it "should be able to return its aliases" do - value = Puppet::Parameter::ValueCollection::Value.new("foo") - value.alias("bar") - value.alias("baz") - value.aliases.should == [:bar, :baz] - end - - [:block, :call, :method, :event, :required_features].each do |attr| - it "should support a #{attr} attribute" do - value = Puppet::Parameter::ValueCollection::Value.new("foo") - value.should respond_to(attr.to_s + "=") - value.should respond_to(attr) - end - end - - it "should default to :instead for :call if a block is provided" do - Puppet::Parameter::ValueCollection::Value.new("foo").call.should == :instead - end - - it "should always return events as symbols" do - value = Puppet::Parameter::ValueCollection::Value.new("foo") - value.event = "foo_test" - value.event.should == :foo_test - end - - describe "when matching" do - describe "a regex" do - it "should return true if the regex matches the value" do - Puppet::Parameter::ValueCollection::Value.new(/\w/).should be_match("foo") - end - - it "should return false if the regex does not match the value" do - Puppet::Parameter::ValueCollection::Value.new(/\d/).should_not be_match("foo") - end - end - - describe "a non-regex" do - it "should return true if the value, converted to a symbol, matches the name" do - Puppet::Parameter::ValueCollection::Value.new("foo").should be_match("foo") - Puppet::Parameter::ValueCollection::Value.new(:foo).should be_match(:foo) - Puppet::Parameter::ValueCollection::Value.new(:foo).should be_match("foo") - Puppet::Parameter::ValueCollection::Value.new("foo").should be_match(:foo) - end - - it "should return false if the value, converted to a symbol, does not match the name" do - Puppet::Parameter::ValueCollection::Value.new(:foo).should_not be_match(:bar) - end - - it "should return true if any of its aliases match" do - value = Puppet::Parameter::ValueCollection::Value.new("foo") - value.alias("bar") - value.should be_match("bar") - end - end - end -end diff --git a/spec/unit/parameter/value.rb b/spec/unit/parameter/value.rb new file mode 100755 index 000000000..f6def01dd --- /dev/null +++ b/spec/unit/parameter/value.rb @@ -0,0 +1,88 @@ +#!/usr/bin/env ruby + +require File.dirname(__FILE__) + '/../../spec_helper' + +require 'puppet/parameter' + +describe Puppet::Parameter::Value do + it "should require a name" do + lambda { Puppet::Parameter::Value.new }.should raise_error(ArgumentError) + end + + it "should set its name" do + Puppet::Parameter::Value.new(:foo).name.should == :foo + end + + it "should support regexes as names" do + lambda { Puppet::Parameter::Value.new(%r{foo}) }.should_not raise_error + end + + it "should mark itself as a regex if its name is a regex" do + Puppet::Parameter::Value.new(%r{foo}).should be_regex + end + + it "should always convert its name to a symbol if it is not a regex" do + Puppet::Parameter::Value.new("foo").name.should == :foo + Puppet::Parameter::Value.new(true).name.should == :true + end + + it "should support adding aliases" do + Puppet::Parameter::Value.new("foo").should respond_to(:alias) + end + + it "should be able to return its aliases" do + value = Puppet::Parameter::Value.new("foo") + value.alias("bar") + value.alias("baz") + value.aliases.should == [:bar, :baz] + end + + [:block, :call, :method, :event, :required_features].each do |attr| + it "should support a #{attr} attribute" do + value = Puppet::Parameter::Value.new("foo") + value.should respond_to(attr.to_s + "=") + value.should respond_to(attr) + end + end + + it "should default to :instead for :call if a block is provided" do + Puppet::Parameter::Value.new("foo").call.should == :instead + end + + it "should always return events as symbols" do + value = Puppet::Parameter::Value.new("foo") + value.event = "foo_test" + value.event.should == :foo_test + end + + describe "when matching" do + describe "a regex" do + it "should return true if the regex matches the value" do + Puppet::Parameter::Value.new(/\w/).should be_match("foo") + end + + it "should return false if the regex does not match the value" do + Puppet::Parameter::Value.new(/\d/).should_not be_match("foo") + end + end + + describe "a non-regex" do + it "should return true if the value, converted to a symbol, matches the name" do + Puppet::Parameter::Value.new("foo").should be_match("foo") + Puppet::Parameter::Value.new(:foo).should be_match(:foo) + Puppet::Parameter::Value.new(:foo).should be_match("foo") + Puppet::Parameter::Value.new("foo").should be_match(:foo) + end + + it "should return false if the value, converted to a symbol, does not match the name" do + Puppet::Parameter::Value.new(:foo).should_not be_match(:bar) + end + + it "should return true if any of its aliases match" do + value = Puppet::Parameter::Value.new("foo") + value.alias("bar") + value.should be_match("bar") + end + end + end +end diff --git a/spec/unit/parameter/value_collection.rb b/spec/unit/parameter/value_collection.rb new file mode 100755 index 000000000..421e5a2ea --- /dev/null +++ b/spec/unit/parameter/value_collection.rb @@ -0,0 +1,167 @@ +#!/usr/bin/env ruby + +require File.dirname(__FILE__) + '/../../spec_helper' + +require 'puppet/parameter' + +describe Puppet::Parameter::ValueCollection do + before do + @collection = Puppet::Parameter::ValueCollection.new + end + + it "should have a method for defining new values" do + @collection.should respond_to(:newvalues) + end + + it "should have a method for adding individual values" do + @collection.should respond_to(:newvalue) + end + + it "should be able to retrieve individual values" do + value = @collection.newvalue(:foo) + @collection.value(:foo).should equal(value) + end + + it "should be able to add an individual value with a block" do + @collection.newvalue(:foo) { raise "testing" } + @collection.value(:foo).block.should be_instance_of(Proc) + end + + it "should be able to add values that are empty strings" do + lambda { @collection.newvalue('') }.should_not raise_error + end + + it "should be able to add values that are empty strings" do + value = @collection.newvalue('') + @collection.match?('').should equal(value) + end + + it "should set :call to :none when adding a value with no block" do + value = @collection.newvalue(:foo) + value.call.should == :none + end + + describe "when adding a value with a block" do + it "should set the method name to 'set_' plus the value name" do + value = @collection.newvalue(:myval) { raise "testing" } + value.method.should == "set_myval" + end + end + + it "should be able to add an individual value with options" do + value = @collection.newvalue(:foo, :call => :bar) + value.call.should == :bar + end + + it "should have a method for validating a value" do + @collection.should respond_to(:validate) + end + + it "should have a method for munging a value" do + @collection.should respond_to(:munge) + end + + it "should be able to generate documentation when it has both values and regexes" do + @collection.newvalues :foo, "bar", %r{test} + @collection.doc.should be_instance_of(String) + end + + it "should correctly generate documentation for values" do + @collection.newvalues :foo + @collection.doc.should be_include("Valid values are ``foo``") + end + + it "should correctly generate documentation for regexes" do + @collection.newvalues %r{\w+} + @collection.doc.should be_include("Values can match ``/\\w+/``") + end + + it "should be able to find the first matching value" do + @collection.newvalues :foo, :bar + @collection.match?("foo").should be_instance_of(Puppet::Parameter::Value) + end + + it "should be able to match symbols" do + @collection.newvalues :foo, :bar + @collection.match?(:foo).should be_instance_of(Puppet::Parameter::Value) + end + + it "should be able to match symbols when a regex is provided" do + @collection.newvalues %r{.} + @collection.match?(:foo).should be_instance_of(Puppet::Parameter::Value) + end + + it "should be able to match values using regexes" do + @collection.newvalues %r{.} + @collection.match?("foo").should_not be_nil + end + + it "should prefer value matches to regex matches" do + @collection.newvalues %r{.}, :foo + @collection.match?("foo").name.should == :foo + end + + describe "when validating values" do + it "should do nothing if no values or regexes have been defined" do + @collection.validate("foo") + end + + it "should fail if the value is not a defined value or alias and does not match a regex" do + @collection.newvalues :foo + lambda { @collection.validate("bar") }.should raise_error(ArgumentError) + end + + it "should succeed if the value is one of the defined values" do + @collection.newvalues :foo + lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError) + end + + it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do + @collection.newvalues :foo + lambda { @collection.validate("foo") }.should_not raise_error(ArgumentError) + end + + it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do + @collection.newvalues "foo" + lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError) + end + + it "should succeed if the value is one of the defined aliases" do + @collection.newvalues :foo + @collection.aliasvalue :bar, :foo + lambda { @collection.validate("bar") }.should_not raise_error(ArgumentError) + end + + it "should succeed if the value matches one of the regexes" do + @collection.newvalues %r{\d} + lambda { @collection.validate("10") }.should_not raise_error(ArgumentError) + end + end + + describe "when munging values" do + it "should do nothing if no values or regexes have been defined" do + @collection.munge("foo").should == "foo" + end + + it "should return return any matching defined values" do + @collection.newvalues :foo, :bar + @collection.munge("foo").should == :foo + end + + it "should return any matching aliases" do + @collection.newvalues :foo + @collection.aliasvalue :bar, :foo + @collection.munge("bar").should == :foo + end + + it "should return the value if it matches a regex" do + @collection.newvalues %r{\w} + @collection.munge("bar").should == "bar" + end + + it "should return the value if no other option is matched" do + @collection.newvalues :foo + @collection.munge("bar").should == "bar" + end + end +end |