From 9fa70ae43f14a9b13343ae67ab8d1520f43ebb4d Mon Sep 17 00:00:00 2001 From: Martin Hellmich Date: Mon, 18 Feb 2013 16:02:15 +0100 Subject: changed .count to .size to support legacy ruby --- lib/puppet/provider/file_line/ruby.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/puppet/provider/file_line/ruby.rb b/lib/puppet/provider/file_line/ruby.rb index e21eaa8..a3219d3 100644 --- a/lib/puppet/provider/file_line/ruby.rb +++ b/lib/puppet/provider/file_line/ruby.rb @@ -34,7 +34,7 @@ Puppet::Type.type(:file_line).provide(:ruby) do def handle_create_with_match() regex = resource[:match] ? Regexp.new(resource[:match]) : nil - match_count = lines.select { |l| regex.match(l) }.count + match_count = lines.select { |l| regex.match(l) }.size if match_count > 1 raise Puppet::Error, "More than one line in file '#{resource[:path]}' matches pattern '#{resource[:match]}'" end -- cgit v1.2.3 From 03c5c4a434c2290c021034dbfed82cb0f97e0e87 Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Mon, 25 Feb 2013 14:00:20 -0800 Subject: (maint) Add Ruby 2.0.0 to Travis build matrix Without this patch we're not testing against Ruby 2.0.0 which has recently been released. This is a problem because we'd like a way to be notified if a change set breaks compatibility with future supported versions of Ruby. This patch should not be taken as an indication that we fully support Ruby 2.0, just as an indication that we plan to in the future. This patch also tightens up the specifications of the build matrix. In addition to testing against the specific Puppet dependency versions, we're also testing against the latest 2.7.x release and the latest release. --- .gemfile | 5 ----- .gitignore | 3 +++ .travis.yml | 25 ++++++++++++++++++------- Gemfile | 8 ++++++++ 4 files changed, 29 insertions(+), 12 deletions(-) delete mode 100644 .gemfile create mode 100644 Gemfile diff --git a/.gemfile b/.gemfile deleted file mode 100644 index 9aad840..0000000 --- a/.gemfile +++ /dev/null @@ -1,5 +0,0 @@ -source :rubygems - -puppetversion = ENV.key?('PUPPET_VERSION') ? "= #{ENV['PUPPET_VERSION']}" : ['>= 2.7'] -gem 'puppet', puppetversion -gem 'puppetlabs_spec_helper', '>= 0.1.0' diff --git a/.gitignore b/.gitignore index 481fc81..416889c 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,6 @@ pkg/ .DS_Store metadata.json coverage/ +Gemfile.lock +.bundle/ +vendor/bundle/ diff --git a/.travis.yml b/.travis.yml index 0ec5a08..7e40b3f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,16 +1,27 @@ language: ruby +bundler_args: --without development +script: "bundle exec rake spec SPEC_OPTS='--color --format documentation'" rvm: - 1.8.7 -before_script: -after_script: -script: "rake spec_full" -branches: - only: - - master env: + - PUPPET_VERSION=">= 3.0.0" + - PUPPET_VERSION="~> 2.7.0" - PUPPET_VERSION=2.7.13 - PUPPET_VERSION=2.7.6 - PUPPET_VERSION=2.6.9 +matrix: + allow_failures: + - rvm: 2.0.0 + include: + - rvm: 2.0.0 + env: PUPPET_VERSION=">= 3.0.0" + - rvm: 1.9.3 + env: PUPPET_VERSION=">= 3.0.0" notifications: email: false -gemfile: .gemfile + webhooks: + urls: + - https://puppet-dev-community.herokuapp.com/event/travis-ci/ + on_success: always + on_failure: always + on_start: yes diff --git a/Gemfile b/Gemfile new file mode 100644 index 0000000..3ddc07e --- /dev/null +++ b/Gemfile @@ -0,0 +1,8 @@ +source "https://rubygems.org" + +if puppetversion = ENV['PUPPET_VERSION'] + gem 'puppet', puppetversion +else + gem 'puppet' +end +gem 'puppetlabs_spec_helper', '>= 0.1.0' -- cgit v1.2.3 From a1510a1e71cafd7c6d20d407e77b1e1fc165475d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Pinson?= Date: Mon, 4 Mar 2013 23:37:57 +0100 Subject: Add missing documentation for validate_augeas and validate_cmd to README.markdown --- README.markdown | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/README.markdown b/README.markdown index c58d31f..f1ac6b3 100644 --- a/README.markdown +++ b/README.markdown @@ -777,6 +777,38 @@ The following values will fail, causing compilation to abort: +- *Type*: statement + +validate_augeas +-------------- +Perform validation of a string using an Augeas lens +The first argument of this function should be a string to +test, and the second argument should be the name of the Augeas lens to use. +If Augeas fails to parse the string with the lens, the compilation will +abort with a parse error. + +A third argument can be specified, listing paths which should +not be found in the file. The `$file` variable points to the location +of the temporary file being tested in the Augeas tree. + +For example, if you want to make sure your passwd content never contains +a user `foo`, you could write: + + validate_augeas($passwdcontent, 'Passwd.lns', ['$file/foo']) + +Or if you wanted to ensure that no users used the '/bin/barsh' shell, +you could use: + + validate_augeas($passwdcontent, 'Passwd.lns', ['$file/*[shell="/bin/barsh"]'] + +If a fourth argument is specified, this will be the error message raised and +seen by the user. + +A helpful error message can be returned like this: + + validate_augeas($sudoerscontent, 'Sudoers.lns', [], 'Failed to validate sudoers content with Augeas') + + - *Type*: statement validate_bool @@ -799,6 +831,29 @@ The following values will fail, causing compilation to abort: +- *Type*: statement + + +validate_cmd +------------- +Perform validation of a string with an external command. +The first argument of this function should be a string to +test, and the second argument should be a path to a test command +taking a file as last argument. If the command, launched against +a tempfile containing the passed string, returns a non-null value, +compilation will abort with a parse error. + +If a third argument is specified, this will be the error message raised and +seen by the user. + +A helpful error message can be returned like this: + +Example: + + validate_cmd($sudoerscontent, '/usr/sbin/visudo -c -f', 'Visudo failed to validate sudoers content') + + + - *Type*: statement validate_hash -- cgit v1.2.3 From 96e19d05f3b07a12a3a965e7d2ec90cacf25cccc Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Mon, 11 Mar 2013 11:06:33 -0700 Subject: Add contributing document Copied from the same one included in Puppet and Facter. [ci skip] --- CONTRIBUTING.md | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 CONTRIBUTING.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..bd11f63 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,65 @@ +# How to contribute + +Third-party patches are essential for keeping stdlib great. We simply can't +access the huge number of platforms and myriad configurations for running +stdlib. We want to keep it as easy as possible to contribute changes that +get things working in your environment. There are a few guidelines that we +need contributors to follow so that we can have a chance of keeping on +top of things. + +## Getting Started + +* Make sure you have a [Redmine account](http://projects.puppetlabs.com) +* Make sure you have a [GitHub account](https://github.com/signup/free) +* Submit a ticket for your issue, assuming one does not already exist. + * Clearly describe the issue including steps to reproduce when it is a bug. + * Make sure you fill in the earliest version that you know has the issue. +* Fork the repository on GitHub + +## Making Changes + +* Create a topic branch from where you want to base your work. + * This is usually the master branch. + * Only target release branches if you are certain your fix must be on that + branch. + * To quickly create a topic branch based on master; `git branch + fix/master/my_contribution master` then checkout the new branch with `git + checkout fix/master/my_contribution`. Please avoid working directly on the + `master` branch. +* Make commits of logical units. +* Check for unnecessary whitespace with `git diff --check` before committing. +* Make sure your commit messages are in the proper format. + +```` + (#99999) Make the example in CONTRIBUTING imperative and concrete + + Without this patch applied the example commit message in the CONTRIBUTING + document is not a concrete example. This is a problem because the + contributor is left to imagine what the commit message should look like + based on a description rather than an example. This patch fixes the + problem by making the example concrete and imperative. + + The first line is a real life imperative statement with a ticket number + from our issue tracker. The body describes the behavior without the patch, + why this is a problem, and how the patch fixes the problem when applied. +```` + +* Make sure you have added the necessary tests for your changes. +* Run _all_ the tests to assure nothing else was accidentally broken. + +## Submitting Changes + +* Sign the [Contributor License Agreement](http://links.puppetlabs.com/cla). +* Push your changes to a topic branch in your fork of the repository. +* Submit a pull request to the repository in the puppetlabs organization. +* Update your Redmine ticket to mark that you have submitted code and are ready for it to be reviewed. + * Include a link to the pull request in the ticket + +# Additional Resources + +* [More information on contributing](http://links.puppetlabs.com/contribute-to-puppet) +* [Bug tracker (Redmine)](http://projects.puppetlabs.com) +* [Contributor License Agreement](http://links.puppetlabs.com/cla) +* [General GitHub documentation](http://help.github.com/) +* [GitHub pull request documentation](http://help.github.com/send-pull-requests/) +* #puppet-dev IRC channel on freenode.org -- cgit v1.2.3 From e80207bede37e498c32bea6d56c46f1dd709721e Mon Sep 17 00:00:00 2001 From: Uwe Stuehler Date: Tue, 23 Oct 2012 16:43:03 +0200 Subject: Fix number of arguments check in flatten() The function only uses the first argument, so raise an error with too few arguments *and* with too many arguments. --- lib/puppet/parser/functions/flatten.rb | 2 +- spec/unit/puppet/parser/functions/flatten_spec.rb | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/puppet/parser/functions/flatten.rb b/lib/puppet/parser/functions/flatten.rb index 781da78..a1ed183 100644 --- a/lib/puppet/parser/functions/flatten.rb +++ b/lib/puppet/parser/functions/flatten.rb @@ -16,7 +16,7 @@ Would return: ['a','b','c'] ) do |arguments| raise(Puppet::ParseError, "flatten(): Wrong number of arguments " + - "given (#{arguments.size} for 1)") if arguments.size < 1 + "given (#{arguments.size} for 1)") if arguments.size != 1 array = arguments[0] diff --git a/spec/unit/puppet/parser/functions/flatten_spec.rb b/spec/unit/puppet/parser/functions/flatten_spec.rb index d4dfd20..dba7a6b 100755 --- a/spec/unit/puppet/parser/functions/flatten_spec.rb +++ b/spec/unit/puppet/parser/functions/flatten_spec.rb @@ -11,6 +11,10 @@ describe "the flatten function" do lambda { scope.function_flatten([]) }.should( raise_error(Puppet::ParseError)) end + it "should raise a ParseError if there is more than 1 argument" do + lambda { scope.function_flatten([[], []]) }.should( raise_error(Puppet::ParseError)) + end + it "should flatten a complex data structure" do result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]]) result.should(eq(["a","b","c","d","e","f","g"])) -- cgit v1.2.3 From 5a11279cc54e7f9f5d168c75728f990d0bd0b694 Mon Sep 17 00:00:00 2001 From: Uwe Stuehler Date: Tue, 23 Oct 2012 16:43:03 +0200 Subject: Fix number of arguments check in flatten() The function only uses the first argument, so raise an error with too few arguments *and* with too many arguments. --- lib/puppet/parser/functions/flatten.rb | 2 +- spec/unit/puppet/parser/functions/flatten_spec.rb | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/puppet/parser/functions/flatten.rb b/lib/puppet/parser/functions/flatten.rb index 781da78..a1ed183 100644 --- a/lib/puppet/parser/functions/flatten.rb +++ b/lib/puppet/parser/functions/flatten.rb @@ -16,7 +16,7 @@ Would return: ['a','b','c'] ) do |arguments| raise(Puppet::ParseError, "flatten(): Wrong number of arguments " + - "given (#{arguments.size} for 1)") if arguments.size < 1 + "given (#{arguments.size} for 1)") if arguments.size != 1 array = arguments[0] diff --git a/spec/unit/puppet/parser/functions/flatten_spec.rb b/spec/unit/puppet/parser/functions/flatten_spec.rb index d4dfd20..dba7a6b 100755 --- a/spec/unit/puppet/parser/functions/flatten_spec.rb +++ b/spec/unit/puppet/parser/functions/flatten_spec.rb @@ -11,6 +11,10 @@ describe "the flatten function" do lambda { scope.function_flatten([]) }.should( raise_error(Puppet::ParseError)) end + it "should raise a ParseError if there is more than 1 argument" do + lambda { scope.function_flatten([[], []]) }.should( raise_error(Puppet::ParseError)) + end + it "should flatten a complex data structure" do result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]]) result.should(eq(["a","b","c","d","e","f","g"])) -- cgit v1.2.3 From 5d5a4d466ed6530fa8b68162e96bdaaaf35066e1 Mon Sep 17 00:00:00 2001 From: Justin Lambert Date: Mon, 17 Dec 2012 06:22:36 -0700 Subject: str2bool should return a boolean if called with a boolean --- lib/puppet/parser/functions/str2bool.rb | 5 +++++ spec/unit/puppet/parser/functions/str2bool_spec.rb | 7 +++++++ 2 files changed, 12 insertions(+) diff --git a/lib/puppet/parser/functions/str2bool.rb b/lib/puppet/parser/functions/str2bool.rb index c320da6..9ea6dd5 100644 --- a/lib/puppet/parser/functions/str2bool.rb +++ b/lib/puppet/parser/functions/str2bool.rb @@ -14,6 +14,11 @@ like: 0, f, n, false, no to 'false'. "given (#{arguments.size} for 1)") if arguments.size < 1 string = arguments[0] + + # If string is already Boolean, return it + if !!string == string + return string + end unless string.is_a?(String) raise(Puppet::ParseError, 'str2bool(): Requires either ' + diff --git a/spec/unit/puppet/parser/functions/str2bool_spec.rb b/spec/unit/puppet/parser/functions/str2bool_spec.rb index 2782bbe..ef6350f 100644 --- a/spec/unit/puppet/parser/functions/str2bool_spec.rb +++ b/spec/unit/puppet/parser/functions/str2bool_spec.rb @@ -21,4 +21,11 @@ describe "the str2bool function" do result = scope.function_str2bool(["undef"]) result.should(eq(false)) end + + it "should return the boolean it was called with" do + result = scope.function_str2bool([true]) + result.should(eq(true)) + result = scope.function_str2bool([false]) + result.should(eq(false)) + end end -- cgit v1.2.3 From 961dcab15d3cf00eabeb5a496efc9da051169241 Mon Sep 17 00:00:00 2001 From: Eric Shamow Date: Tue, 3 Apr 2012 22:30:46 -0400 Subject: (#13610) Add is_function_available to stdlib This function provides a simple wrapper around Puppet::Parser::Functions.function for access within Puppet manifests. This will allow users to check whether or not a plugin or functionality such as hiera is installed on the server. --- .../parser/functions/is_function_available.rb | 23 ++++++++++++++++ .../parser/functions/is_function_available.rb | 31 ++++++++++++++++++++++ 2 files changed, 54 insertions(+) create mode 100644 lib/puppet/parser/functions/is_function_available.rb create mode 100644 spec/unit/puppet/parser/functions/is_function_available.rb diff --git a/lib/puppet/parser/functions/is_function_available.rb b/lib/puppet/parser/functions/is_function_available.rb new file mode 100644 index 0000000..6cbd35c --- /dev/null +++ b/lib/puppet/parser/functions/is_function_available.rb @@ -0,0 +1,23 @@ +# +# is_function_available.rb +# + +module Puppet::Parser::Functions + newfunction(:is_function_available, :type => :rvalue, :doc => <<-EOS +This function accepts a string as an argument, determines whether the +Puppet runtime has access to a function by that name. It returns a +true if the function exists, false if not. + EOS + ) do |arguments| + + if (arguments.size != 1) then + raise(Puppet::ParseError, "is_function_available?(): Wrong number of arguments "+ + "given #{arguments.size} for 1") + end + + function = Puppet::Parser::Functions.function(arguments[0].to_sym) + function.is_a?(String) and not function.empty? + end +end + +# vim: set ts=2 sw=2 et : diff --git a/spec/unit/puppet/parser/functions/is_function_available.rb b/spec/unit/puppet/parser/functions/is_function_available.rb new file mode 100644 index 0000000..bd40c51 --- /dev/null +++ b/spec/unit/puppet/parser/functions/is_function_available.rb @@ -0,0 +1,31 @@ +#!/usr/bin/env rspec +require 'spec_helper' + +describe "the is_function_available function" do + before :all do + Puppet::Parser::Functions.autoloader.loadall + end + + before :each do + @scope = Puppet::Parser::Scope.new + end + + it "should exist" do + Puppet::Parser::Functions.function("is_function_available").should == "function_is_function_available" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { @scope.function_is_function_available([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should return false if a nonexistent function is passed" do + result = @scope.function_is_function_available(['jeff_mccunes_left_sock']) + result.should(eq(false)) + end + + it "should return true if an available function is passed" do + result = @scope.function_is_function_available(['require']) + result.should(eq(true)) + end + +end -- cgit v1.2.3 From 05273419e1c8b34115ede15b1d8a8739f6a0db00 Mon Sep 17 00:00:00 2001 From: Kristof Willaert Date: Tue, 19 Mar 2013 10:00:57 +0100 Subject: Add floor function implementation and unit tests --- README.markdown | 14 +++++++++ lib/puppet/parser/functions/floor.rb | 20 +++++++++++++ spec/unit/puppet/parser/functions/floor_spec.rb | 39 +++++++++++++++++++++++++ 3 files changed, 73 insertions(+) create mode 100644 lib/puppet/parser/functions/floor.rb create mode 100644 spec/unit/puppet/parser/functions/floor_spec.rb diff --git a/README.markdown b/README.markdown index f1ac6b3..121b784 100644 --- a/README.markdown +++ b/README.markdown @@ -196,6 +196,20 @@ as a result. Would return: ['a','b','c'] +- *Type*: rvalue + +floor +----- +Returns the largest integer less or equal to the argument. +Takes a single numeric value as an argument. + +*Examples:* + + floor('3.8') + +Would return: '3' + + - *Type*: rvalue fqdn_rotate diff --git a/lib/puppet/parser/functions/floor.rb b/lib/puppet/parser/functions/floor.rb new file mode 100644 index 0000000..a401923 --- /dev/null +++ b/lib/puppet/parser/functions/floor.rb @@ -0,0 +1,20 @@ +module Puppet::Parser::Functions + newfunction(:floor, :type => :rvalue, :doc => <<-EOS + Returns the largest integer less or equal to the argument. + Takes a single numeric value as an argument. + EOS + ) do |arguments| + + raise(Puppet::ParseError, "floor(): Wrong number of arguments " + + "given (#{arguments.size} for 1)") if arguments.size != 1 + + arg = arguments[0] + + raise(Puppet::ParseError, "floor(): Wrong argument type " + + "given (#{arg.class} for Numeric)") if arg.is_a?(Numeric) == false + + arg.floor + end +end + +# vim: set ts=2 sw=2 et : diff --git a/spec/unit/puppet/parser/functions/floor_spec.rb b/spec/unit/puppet/parser/functions/floor_spec.rb new file mode 100644 index 0000000..dbc8c77 --- /dev/null +++ b/spec/unit/puppet/parser/functions/floor_spec.rb @@ -0,0 +1,39 @@ +#! /usr/bin/env ruby -S rspec + +require 'spec_helper' + +describe "the floor function" do + let(:scope) { PuppetlabsSpec::PuppetInternals.scope } + + it "should exist" do + Puppet::Parser::Functions.function("floor").should == "function_floor" + end + + it "should raise a ParseError if there is less than 1 argument" do + lambda { scope.function_floor([]) }.should( raise_error(Puppet::ParseError, /Wrong number of arguments/)) + end + + it "should should raise a ParseError if input isn't numeric (eg. String)" do + lambda { scope.function_floor(["foo"]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/)) + end + + it "should should raise a ParseError if input isn't numeric (eg. Boolean)" do + lambda { scope.function_floor([true]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/)) + end + + it "should return an integer when a numeric type is passed" do + result = scope.function_floor([12.4]) + result.is_a?(Integer).should(eq(true)) + end + + it "should return the input when an integer is passed" do + result = scope.function_floor([7]) + result.should(eq(7)) + end + + it "should return the largest integer less than or equal to the input" do + result = scope.function_floor([3.8]) + result.should(eq(3)) + end +end + -- cgit v1.2.3 From 88a93ac6cdf38045e1cf29325a70e5e4143016b3 Mon Sep 17 00:00:00 2001 From: Richard Soderberg Date: Tue, 26 Mar 2013 15:45:40 -0700 Subject: add suffix function to accompany the prefix function --- README.markdown | 13 +++++++ lib/puppet/parser/functions/suffix.rb | 45 ++++++++++++++++++++++++ spec/unit/puppet/parser/functions/suffix_spec.rb | 19 ++++++++++ 3 files changed, 77 insertions(+) create mode 100644 lib/puppet/parser/functions/suffix.rb create mode 100644 spec/unit/puppet/parser/functions/suffix_spec.rb diff --git a/README.markdown b/README.markdown index 121b784..2f93db4 100644 --- a/README.markdown +++ b/README.markdown @@ -659,6 +659,19 @@ every string inside an array. Would result in: "aaa" +- *Type*: rvalue + +suffix +------ +This function applies a suffix to all elements in an array. + +*Examples:* + + suffix(['a','b','c'], 'p') + +Will return: ['ap','bp','cp'] + + - *Type*: rvalue swapcase diff --git a/lib/puppet/parser/functions/suffix.rb b/lib/puppet/parser/functions/suffix.rb new file mode 100644 index 0000000..5018280 --- /dev/null +++ b/lib/puppet/parser/functions/suffix.rb @@ -0,0 +1,45 @@ +# +# suffix.rb +# + +module Puppet::Parser::Functions + newfunction(:suffix, :type => :rvalue, :doc => <<-EOS +This function applies a suffix to all elements in an array. + +*Examples:* + + suffix(['a','b','c'], 'p') + +Will return: ['ap','bp','cp'] + EOS + ) do |arguments| + + # Technically we support two arguments but only first is mandatory ... + raise(Puppet::ParseError, "suffix(): Wrong number of arguments " + + "given (#{arguments.size} for 1)") if arguments.size < 1 + + array = arguments[0] + + unless array.is_a?(Array) + raise(Puppet::ParseError, 'suffix(): Requires array to work with') + end + + suffix = arguments[1] if arguments[1] + + if suffix + unless suffix.is_a?(String) + raise(Puppet::ParseError, 'suffix(): Requires string to work with') + end + end + + # Turn everything into string same as join would do ... + result = array.collect do |i| + i = i.to_s + suffix ? i + suffix : i + end + + return result + end +end + +# vim: set ts=2 sw=2 et : diff --git a/spec/unit/puppet/parser/functions/suffix_spec.rb b/spec/unit/puppet/parser/functions/suffix_spec.rb new file mode 100644 index 0000000..c28f719 --- /dev/null +++ b/spec/unit/puppet/parser/functions/suffix_spec.rb @@ -0,0 +1,19 @@ +#! /usr/bin/env ruby -S rspec +require 'spec_helper' + +describe "the suffix function" do + let(:scope) { PuppetlabsSpec::PuppetInternals.scope } + + it "should exist" do + Puppet::Parser::Functions.function("suffix").should == "function_suffix" + end + + it "should raise a ParseError if there is less than 1 arguments" do + lambda { scope.function_suffix([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should return a suffixed array" do + result = scope.function_suffix([['a','b','c'], 'p']) + result.should(eq(['ap','bp','cp'])) + end +end -- cgit v1.2.3 From a83318d3ee41683118a55a2b15769c97efbcf6d9 Mon Sep 17 00:00:00 2001 From: Richard Soderberg Date: Tue, 26 Mar 2013 15:49:09 -0700 Subject: prefix: fix doc typo Examles -> Examples --- README.markdown | 2 +- lib/puppet/parser/functions/prefix.rb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.markdown b/README.markdown index 2f93db4..336d0ab 100644 --- a/README.markdown +++ b/README.markdown @@ -479,7 +479,7 @@ prefix ------ This function applies a prefix to all elements in an array. -*Examles:* +*Examples:* prefix(['a','b','c'], 'p') diff --git a/lib/puppet/parser/functions/prefix.rb b/lib/puppet/parser/functions/prefix.rb index 4593976..243cf18 100644 --- a/lib/puppet/parser/functions/prefix.rb +++ b/lib/puppet/parser/functions/prefix.rb @@ -6,7 +6,7 @@ module Puppet::Parser::Functions newfunction(:prefix, :type => :rvalue, :doc => <<-EOS This function applies a prefix to all elements in an array. -*Examles:* +*Examples:* prefix(['a','b','c'], 'p') -- cgit v1.2.3 From 29402f31e73a426dcc449216010834884d0251ec Mon Sep 17 00:00:00 2001 From: Adrien Thebo Date: Wed, 27 Mar 2013 13:37:25 -0700 Subject: (maint) better error reporting for prefix and suffix When prefix and suffix did error checking with positional arguments, they would not report the position of the argument that failed to validate. This commit changes the messages to indicate which argument failed. --- lib/puppet/parser/functions/prefix.rb | 4 ++-- lib/puppet/parser/functions/suffix.rb | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/puppet/parser/functions/prefix.rb b/lib/puppet/parser/functions/prefix.rb index 243cf18..62211ae 100644 --- a/lib/puppet/parser/functions/prefix.rb +++ b/lib/puppet/parser/functions/prefix.rb @@ -21,14 +21,14 @@ Will return: ['pa','pb','pc'] array = arguments[0] unless array.is_a?(Array) - raise(Puppet::ParseError, 'prefix(): Requires array to work with') + raise Puppet::ParseError, "prefix(): expected first argument to be an Array, got #{array.inspect}" end prefix = arguments[1] if arguments[1] if prefix unless prefix.is_a?(String) - raise(Puppet::ParseError, 'prefix(): Requires string to work with') + raise Puppet::ParseError, "prefix(): expected second argument to be a String, got #{suffix.inspect}" end end diff --git a/lib/puppet/parser/functions/suffix.rb b/lib/puppet/parser/functions/suffix.rb index 5018280..f7792d6 100644 --- a/lib/puppet/parser/functions/suffix.rb +++ b/lib/puppet/parser/functions/suffix.rb @@ -21,14 +21,14 @@ Will return: ['ap','bp','cp'] array = arguments[0] unless array.is_a?(Array) - raise(Puppet::ParseError, 'suffix(): Requires array to work with') + raise Puppet::ParseError, "suffix(): expected first argument to be an Array, got #{array.inspect}" end suffix = arguments[1] if arguments[1] if suffix - unless suffix.is_a?(String) - raise(Puppet::ParseError, 'suffix(): Requires string to work with') + unless suffix.is_a? String + raise Puppet::ParseError, "suffix(): expected second argument to be a String, got #{suffix.inspect}" end end -- cgit v1.2.3 From ff5dd5d75adb3723e106ca20bac4e68466395a56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Dal=C3=A9n?= Date: Wed, 20 Mar 2013 16:36:20 +0100 Subject: Allow comparisons of Numeric and number as String Puppet passes numbers as String to functions, but it makes more sense to compare them as Numeric. But sometimes Puppet passes them as the wrong type, see: https://projects.puppetlabs.com/issues/19812 --- lib/puppet/parser/functions/max.rb | 10 +++++++++- lib/puppet/parser/functions/min.rb | 10 +++++++++- spec/unit/puppet/parser/functions/max_spec.rb | 4 ++++ spec/unit/puppet/parser/functions/min_spec.rb | 4 ++++ 4 files changed, 26 insertions(+), 2 deletions(-) diff --git a/lib/puppet/parser/functions/max.rb b/lib/puppet/parser/functions/max.rb index 10b6f74..60fb94a 100644 --- a/lib/puppet/parser/functions/max.rb +++ b/lib/puppet/parser/functions/max.rb @@ -8,6 +8,14 @@ module Puppet::Parser::Functions raise(Puppet::ParseError, "max(): Wrong number of arguments " + "need at least one") if args.size == 0 - return args.max + # Sometimes we get numbers as numerics and sometimes as strings. + # We try to compare them as numbers when possible + return args.max do |a,b| + if a.to_s =~ /\A-?\d+(.\d+)?\z/ and b.to_s =~ /\A-?\d+(.\d+)?\z/ then + a.to_f <=> b.to_f + else + a.to_s <=> b.to_s + end + end end end diff --git a/lib/puppet/parser/functions/min.rb b/lib/puppet/parser/functions/min.rb index abf1b62..6bd6ebf 100644 --- a/lib/puppet/parser/functions/min.rb +++ b/lib/puppet/parser/functions/min.rb @@ -8,6 +8,14 @@ module Puppet::Parser::Functions raise(Puppet::ParseError, "min(): Wrong number of arguments " + "need at least one") if args.size == 0 - return args.min + # Sometimes we get numbers as numerics and sometimes as strings. + # We try to compare them as numbers when possible + return args.min do |a,b| + if a.to_s =~ /\A^-?\d+(.\d+)?\z/ and b.to_s =~ /\A-?\d+(.\d+)?\z/ then + a.to_f <=> b.to_f + else + a.to_s <=> b.to_s + end + end end end diff --git a/spec/unit/puppet/parser/functions/max_spec.rb b/spec/unit/puppet/parser/functions/max_spec.rb index 604927e..ff6f2b3 100755 --- a/spec/unit/puppet/parser/functions/max_spec.rb +++ b/spec/unit/puppet/parser/functions/max_spec.rb @@ -20,4 +20,8 @@ describe "the max function" do it "should be able to compare numbers" do scope.function_max([6,8,4]).should(eq(8)) end + + it "should be able to compare a number with a stringified number" do + scope.function_max([1,"2"]).should(eq("2")) + end end diff --git a/spec/unit/puppet/parser/functions/min_spec.rb b/spec/unit/puppet/parser/functions/min_spec.rb index 781422c..71d593e 100755 --- a/spec/unit/puppet/parser/functions/min_spec.rb +++ b/spec/unit/puppet/parser/functions/min_spec.rb @@ -20,4 +20,8 @@ describe "the min function" do it "should be able to compare numbers" do scope.function_min([6,8,4]).should(eq(4)) end + + it "should be able to compare a number with a stringified number" do + scope.function_min([1,"2"]).should(eq(1)) + end end -- cgit v1.2.3 From e6916f83fd35989db4b86dfb10716c9198994389 Mon Sep 17 00:00:00 2001 From: Steve Huff Date: Fri, 29 Mar 2013 10:04:05 -0400 Subject: Enable num2bool to accept numeric input Also ignore rspec fixtures directory --- .gitignore | 1 + lib/puppet/parser/functions/num2bool.rb | 3 ++- spec/unit/puppet/parser/functions/num2bool_spec.rb | 24 ++++++++++++++++++++-- 3 files changed, 25 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 416889c..2e3ca63 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ pkg/ .DS_Store metadata.json coverage/ +spec/fixtures/ Gemfile.lock .bundle/ vendor/bundle/ diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb index 874db22..638f693 100644 --- a/lib/puppet/parser/functions/num2bool.rb +++ b/lib/puppet/parser/functions/num2bool.rb @@ -14,7 +14,8 @@ higher then 0 become true. raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " + "given (#{arguments.size} for 1)") if arguments.size < 1 - number = arguments[0] + # Since we're matching against a regex, coerce to String + number = arguments[0].to_s # Only numbers allowed ... unless number.match(/^\-?\d+$/) diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb index 640c689..e51ee45 100644 --- a/spec/unit/puppet/parser/functions/num2bool_spec.rb +++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb @@ -12,13 +12,33 @@ describe "the num2bool function" do lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError)) end - it "should return true if 1" do + it "should return true if passed string 1" do result = scope.function_num2bool(["1"]) result.should(be_true) end - it "should return false if 0" do + it "should return true if passed number 1" do + result = scope.function_num2bool([1]) + result.should(be_true) + end + + it "should return false if passed string 0" do result = scope.function_num2bool(["0"]) result.should(be_false) end + + it "should return false if passed number 0" do + result = scope.function_num2bool([0]) + result.should(be_false) + end + + it "should return false if passed string -1" do + result = scope.function_num2bool(["-1"]) + result.should(be_false) + end + + it "should return false if passed number -1" do + result = scope.function_num2bool([-1]) + result.should(be_false) + end end -- cgit v1.2.3 From 4a5218a8af8c3ffaf9ea2348a3900b19d6a95416 Mon Sep 17 00:00:00 2001 From: Steve Huff Date: Fri, 29 Mar 2013 12:03:33 -0400 Subject: Reworked number-handling logic No more coercing to String and regex matching. Instead, we now coerce to Integer at the beginning or raise an error if we cannot coerce to Integer. A consequence of this change is that the function will now accept blatantly non-numeric strings as input, and return false. This seems a bit goofy to me, but it's how String#to_i works. If we really don't like this, then I'm open to suggestions. --- lib/puppet/parser/functions/num2bool.rb | 35 +++++++--------------- spec/unit/puppet/parser/functions/num2bool_spec.rb | 11 ++++++- 2 files changed, 21 insertions(+), 25 deletions(-) diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb index 638f693..15dd560 100644 --- a/lib/puppet/parser/functions/num2bool.rb +++ b/lib/puppet/parser/functions/num2bool.rb @@ -2,39 +2,26 @@ # num2bool.rb # -# TODO(Krzysztof Wilczynski): We probably need to approach numeric values differently ... - module Puppet::Parser::Functions newfunction(:num2bool, :type => :rvalue, :doc => <<-EOS -This function converts a number into a true boolean. Zero becomes false. Numbers -higher then 0 become true. +This function converts a number or a string representation of a number into a +true boolean. Zero or anything non-numeric becomes false. Numbers higher then 0 +become true. EOS ) do |arguments| raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " + - "given (#{arguments.size} for 1)") if arguments.size < 1 - - # Since we're matching against a regex, coerce to String - number = arguments[0].to_s - - # Only numbers allowed ... - unless number.match(/^\-?\d+$/) - raise(Puppet::ParseError, 'num2bool(): Requires integer to work with') - end + "given (#{arguments.size} for 1)") if arguments.size != 1 - result = case number - when /^0$/ - false - when /^\-?\d+$/ - # Numbers in Puppet are often string-encoded which is troublesome ... - number = number.to_i - # We yield true for any positive number and false otherwise ... - number > 0 ? true : false - else - raise(Puppet::ParseError, 'num2bool(): Unknown numeric format given') + # we need to get an Integer out of this + begin + number = arguments[0].to_i + rescue NoMethodError + raise(Puppet::ParseError, 'num2bool(): Unable to parse number: ' + $!) end - return result + # Return true for any positive number and false otherwise + return number > 0 ? true : false end end diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb index e51ee45..5ce981e 100644 --- a/spec/unit/puppet/parser/functions/num2bool_spec.rb +++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb @@ -8,10 +8,14 @@ describe "the num2bool function" do Puppet::Parser::Functions.function("num2bool").should == "function_num2bool" end - it "should raise a ParseError if there is less than 1 arguments" do + it "should raise a ParseError if there are no arguments" do lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError)) end + it "should raise a ParseError if there are more than 1 arguments" do + lambda { scope.function_num2bool(["foo","bar"]) }.should( raise_error(Puppet::ParseError)) + end + it "should return true if passed string 1" do result = scope.function_num2bool(["1"]) result.should(be_true) @@ -41,4 +45,9 @@ describe "the num2bool function" do result = scope.function_num2bool([-1]) result.should(be_false) end + + it "should return false if passed something non-numeric" do + result = scope.function_num2bool(["xyzzy"]) + result.should(be_false) + end end -- cgit v1.2.3 From 8d217f0012fef332642faf485ad187773a95bcc1 Mon Sep 17 00:00:00 2001 From: Steve Huff Date: Fri, 29 Mar 2013 15:06:36 -0400 Subject: (19864) num2bool match fix This is a bit more heavy-handed than I might like, but it does appear to do the right things: * accepts numeric input appropriately, truncating floats * matches string input against a regex, then coerces number-looking strings to int * makes a best effort to coerce anything else to a string, then subjects it to the same treatment * raises an error in the event of incorrect number of arguments or non-number-looking strings I've also included some additional unit tests. --- lib/puppet/parser/functions/num2bool.rb | 29 ++++++++++++++---- spec/unit/puppet/parser/functions/num2bool_spec.rb | 34 ++++++++++++++++++++-- 2 files changed, 56 insertions(+), 7 deletions(-) diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb index 15dd560..cf98f80 100644 --- a/lib/puppet/parser/functions/num2bool.rb +++ b/lib/puppet/parser/functions/num2bool.rb @@ -13,13 +13,32 @@ become true. raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " + "given (#{arguments.size} for 1)") if arguments.size != 1 - # we need to get an Integer out of this - begin - number = arguments[0].to_i - rescue NoMethodError - raise(Puppet::ParseError, 'num2bool(): Unable to parse number: ' + $!) + number = arguments[0] + + case number + when Numeric + # Yay, it's a number + when String + # Deal with strings later + else + begin + number = number.to_s + rescue NoMethodError + raise(Puppet::ParseError, 'num2bool(): Unable to parse argument: ' + $!) + end + end + + case number + when String + # Only accept strings that look somewhat like numbers + unless number =~ /^-?\d+/ + raise(Puppet::ParseError, "num2bool(): '#{number}' does not look like a number") + end end + # Truncate floats + number = number.to_i + # Return true for any positive number and false otherwise return number > 0 ? true : false end diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb index 5ce981e..038881f 100644 --- a/spec/unit/puppet/parser/functions/num2bool_spec.rb +++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb @@ -16,6 +16,10 @@ describe "the num2bool function" do lambda { scope.function_num2bool(["foo","bar"]) }.should( raise_error(Puppet::ParseError)) end + it "should raise a ParseError if passed something non-numeric" do + lambda { scope.function_num2bool(["xyzzy"]) }.should( raise_error(Puppet::ParseError)) + end + it "should return true if passed string 1" do result = scope.function_num2bool(["1"]) result.should(be_true) @@ -26,6 +30,16 @@ describe "the num2bool function" do result.should(be_true) end + it "should return true if passed array with string 1" do + result = scope.function_num2bool([["1"]]) + result.should(be_true) + end + + it "should return true if passed array with number 1" do + result = scope.function_num2bool([[1]]) + result.should(be_true) + end + it "should return false if passed string 0" do result = scope.function_num2bool(["0"]) result.should(be_false) @@ -36,6 +50,16 @@ describe "the num2bool function" do result.should(be_false) end + it "should return false if passed array with string 0" do + result = scope.function_num2bool([["0"]]) + result.should(be_false) + end + + it "should return false if passed array with number 0" do + result = scope.function_num2bool([[0]]) + result.should(be_false) + end + it "should return false if passed string -1" do result = scope.function_num2bool(["-1"]) result.should(be_false) @@ -46,8 +70,14 @@ describe "the num2bool function" do result.should(be_false) end - it "should return false if passed something non-numeric" do - result = scope.function_num2bool(["xyzzy"]) + it "should return false if passed array with string -1" do + result = scope.function_num2bool([["-1"]]) result.should(be_false) end + + it "should return false if passed array with number -1" do + result = scope.function_num2bool([[-1]]) + result.should(be_false) + end + end -- cgit v1.2.3 From c372f177708df4c844337e9901646b7b84b86cd8 Mon Sep 17 00:00:00 2001 From: Steve Huff Date: Mon, 1 Apr 2013 11:44:09 -0400 Subject: Cleanup per adrianthebo suggestions * use Float() to process string arguments * get rid of doubly nested arrays * removing needless ternary operator * improving error message handling --- lib/puppet/parser/functions/num2bool.rb | 22 ++++++------- spec/unit/puppet/parser/functions/num2bool_spec.rb | 36 ++++++---------------- 2 files changed, 19 insertions(+), 39 deletions(-) diff --git a/lib/puppet/parser/functions/num2bool.rb b/lib/puppet/parser/functions/num2bool.rb index cf98f80..af0e6ed 100644 --- a/lib/puppet/parser/functions/num2bool.rb +++ b/lib/puppet/parser/functions/num2bool.rb @@ -19,28 +19,24 @@ become true. when Numeric # Yay, it's a number when String - # Deal with strings later + begin + number = Float(number) + rescue ArgumentError => ex + raise(Puppet::ParseError, "num2bool(): '#{number}' does not look like a number: #{ex.message}") + end else begin number = number.to_s - rescue NoMethodError - raise(Puppet::ParseError, 'num2bool(): Unable to parse argument: ' + $!) - end - end - - case number - when String - # Only accept strings that look somewhat like numbers - unless number =~ /^-?\d+/ - raise(Puppet::ParseError, "num2bool(): '#{number}' does not look like a number") + rescue NoMethodError => ex + raise(Puppet::ParseError, "num2bool(): Unable to parse argument: #{ex.message}") end end - # Truncate floats + # Truncate Floats number = number.to_i # Return true for any positive number and false otherwise - return number > 0 ? true : false + return number > 0 end end diff --git a/spec/unit/puppet/parser/functions/num2bool_spec.rb b/spec/unit/puppet/parser/functions/num2bool_spec.rb index 038881f..b56196d 100644 --- a/spec/unit/puppet/parser/functions/num2bool_spec.rb +++ b/spec/unit/puppet/parser/functions/num2bool_spec.rb @@ -25,18 +25,13 @@ describe "the num2bool function" do result.should(be_true) end - it "should return true if passed number 1" do - result = scope.function_num2bool([1]) - result.should(be_true) - end - - it "should return true if passed array with string 1" do - result = scope.function_num2bool([["1"]]) + it "should return true if passed string 1.5" do + result = scope.function_num2bool(["1.5"]) result.should(be_true) end - it "should return true if passed array with number 1" do - result = scope.function_num2bool([[1]]) + it "should return true if passed number 1" do + result = scope.function_num2bool([1]) result.should(be_true) end @@ -50,34 +45,23 @@ describe "the num2bool function" do result.should(be_false) end - it "should return false if passed array with string 0" do - result = scope.function_num2bool([["0"]]) - result.should(be_false) - end - - it "should return false if passed array with number 0" do - result = scope.function_num2bool([[0]]) - result.should(be_false) - end - it "should return false if passed string -1" do result = scope.function_num2bool(["-1"]) result.should(be_false) end - it "should return false if passed number -1" do - result = scope.function_num2bool([-1]) + it "should return false if passed string -1.5" do + result = scope.function_num2bool(["-1.5"]) result.should(be_false) end - it "should return false if passed array with string -1" do - result = scope.function_num2bool([["-1"]]) + it "should return false if passed number -1" do + result = scope.function_num2bool([-1]) result.should(be_false) end - it "should return false if passed array with number -1" do - result = scope.function_num2bool([[-1]]) + it "should return false if passed float -1.5" do + result = scope.function_num2bool([-1.5]) result.should(be_false) end - end -- cgit v1.2.3 From 7a2fb80834d3ec4d21efe58e5e8af188e5bdd07c Mon Sep 17 00:00:00 2001 From: Amos Shapira Date: Sun, 31 Mar 2013 23:37:30 +1100 Subject: (#19998) Implement any2array This change is to implement a new function "any2array", which will take any argument or arguments and create an array which contains it. If the argument is a single array then it will be returned as-is. If the argument is a single hash then it will be converted into an array. Otherwise (if there are more than one argument, or the only argument is not an array or a hash) the function will return an array containing all the arguments. --- lib/puppet/parser/functions/any2array.rb | 35 ++++++++++++++ .../unit/puppet/parser/functions/any2array_spec.rb | 55 ++++++++++++++++++++++ 2 files changed, 90 insertions(+) create mode 100644 lib/puppet/parser/functions/any2array.rb create mode 100644 spec/unit/puppet/parser/functions/any2array_spec.rb diff --git a/lib/puppet/parser/functions/any2array.rb b/lib/puppet/parser/functions/any2array.rb new file mode 100644 index 0000000..d150743 --- /dev/null +++ b/lib/puppet/parser/functions/any2array.rb @@ -0,0 +1,35 @@ +# +# str2bool.rb +# + +module Puppet::Parser::Functions + newfunction(:any2array, :type => :rvalue, :doc => <<-EOS +This converts any object to an array containing that object. Empty argument +lists are converted to an empty array. Arrays are left untouched. Hashes are +converted to arrays of alternating keys and values. + EOS + ) do |arguments| + + if arguments.empty? + return [] + end + + if arguments.length == 1 + if arguments[0].kind_of?(Array) + return arguments[0] + elsif arguments[0].kind_of?(Hash) + result = [] + arguments[0].each do |key, value| + result << key << value + end + return result + else + return [arguments[0]] + end + end + + return arguments + end +end + +# vim: set ts=2 sw=2 et : diff --git a/spec/unit/puppet/parser/functions/any2array_spec.rb b/spec/unit/puppet/parser/functions/any2array_spec.rb new file mode 100644 index 0000000..b266e84 --- /dev/null +++ b/spec/unit/puppet/parser/functions/any2array_spec.rb @@ -0,0 +1,55 @@ +#! /usr/bin/env ruby -S rspec +require 'spec_helper' + +describe "the any2array function" do + let(:scope) { PuppetlabsSpec::PuppetInternals.scope } + + it "should exist" do + Puppet::Parser::Functions.function("any2array").should == "function_any2array" + end + + it "should return an empty array if there is less than 1 argument" do + result = scope.function_any2array([]) + result.should(eq([])) + end + + it "should convert boolean true to [ true ] " do + result = scope.function_any2array([true]) + result.should(eq([true])) + end + + it "should convert one object to [object]" do + result = scope.function_any2array(['one']) + result.should(eq(['one'])) + end + + it "should convert multiple objects to [objects]" do + result = scope.function_any2array(['one', 'two']) + result.should(eq(['one', 'two'])) + end + + it "should return empty array it was called with" do + result = scope.function_any2array([[]]) + result.should(eq([])) + end + + it "should return one-member array it was called with" do + result = scope.function_any2array([['string']]) + result.should(eq(['string'])) + end + + it "should return multi-member array it was called with" do + result = scope.function_any2array([['one', 'two']]) + result.should(eq(['one', 'two'])) + end + + it "should return members of a hash it was called with" do + result = scope.function_any2array([{ 'key' => 'value' }]) + result.should(eq(['key', 'value'])) + end + + it "should return an empty array if it was called with an empty hash" do + result = scope.function_any2array([{ }]) + result.should(eq([])) + end +end -- cgit v1.2.3 From 003cde074c86f034d2730eeb40d676d4e35c6022 Mon Sep 17 00:00:00 2001 From: Amos Shapira Date: Sun, 31 Mar 2013 23:47:11 +1100 Subject: (#19998) fix name of function in a comment --- lib/puppet/parser/functions/any2array.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/puppet/parser/functions/any2array.rb b/lib/puppet/parser/functions/any2array.rb index d150743..95944e1 100644 --- a/lib/puppet/parser/functions/any2array.rb +++ b/lib/puppet/parser/functions/any2array.rb @@ -1,5 +1,5 @@ # -# str2bool.rb +# any2array.rb # module Puppet::Parser::Functions -- cgit v1.2.3 From e7d394b6e9fc3ca07803d18fcf2f5d19b91e92e0 Mon Sep 17 00:00:00 2001 From: Amos Shapira Date: Mon, 1 Apr 2013 14:52:07 +1100 Subject: Remove resundant code --- lib/puppet/parser/functions/any2array.rb | 2 -- 1 file changed, 2 deletions(-) diff --git a/lib/puppet/parser/functions/any2array.rb b/lib/puppet/parser/functions/any2array.rb index 95944e1..e71407e 100644 --- a/lib/puppet/parser/functions/any2array.rb +++ b/lib/puppet/parser/functions/any2array.rb @@ -23,8 +23,6 @@ converted to arrays of alternating keys and values. result << key << value end return result - else - return [arguments[0]] end end -- cgit v1.2.3 From 6647d1c69d1feb20d0d51a9cbd8734259bac4ef3 Mon Sep 17 00:00:00 2001 From: Adrien Thebo Date: Mon, 25 Feb 2013 14:00:20 -0800 Subject: (maint) Backport Gemfile and .travis.yml to 2.x This is a partial backport and update of 03c5c4a434c2290c021034dbfed82cb0f97e0e87 to add travis-ci support and a Gemfile to 2.x. Right now we're not testing 2.x in travis-ci and we're experiencing spec failures because we have to install rspec-puppet from git. The best resolution for this is to consistently use a Gemfile for running tests. This commit also rewrites the .travis.yml for 2.x to only test 2.x versions against ruby 1.8.7 and Puppet < 3.0 Conflicts: .travis.yml --- .gitignore | 3 +++ .travis.yml | 18 ++++++++++++++++++ Gemfile | 8 ++++++++ 3 files changed, 29 insertions(+) create mode 100644 .travis.yml create mode 100644 Gemfile diff --git a/.gitignore b/.gitignore index 481fc81..416889c 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,6 @@ pkg/ .DS_Store metadata.json coverage/ +Gemfile.lock +.bundle/ +vendor/bundle/ diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..266e55a --- /dev/null +++ b/.travis.yml @@ -0,0 +1,18 @@ +language: ruby +bundler_args: --without development +script: "bundle exec rake spec SPEC_OPTS='--color --format documentation'" +rvm: + - 1.8.7 +env: + - PUPPET_VERSION="~> 2.7.0" + - PUPPET_VERSION=2.7.13 + - PUPPET_VERSION=2.7.6 + - PUPPET_VERSION=2.6.9 +notifications: + email: false + webhooks: + urls: + - https://puppet-dev-community.herokuapp.com/event/travis-ci/ + on_success: always + on_failure: always + on_start: yes diff --git a/Gemfile b/Gemfile new file mode 100644 index 0000000..3ddc07e --- /dev/null +++ b/Gemfile @@ -0,0 +1,8 @@ +source "https://rubygems.org" + +if puppetversion = ENV['PUPPET_VERSION'] + gem 'puppet', puppetversion +else + gem 'puppet' +end +gem 'puppetlabs_spec_helper', '>= 0.1.0' -- cgit v1.2.3 From f28550e78996f908b076cdc9aebcbe584c777cd0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Dal=C3=A9n?= Date: Wed, 10 Apr 2013 14:38:14 +0200 Subject: Add a count function Similar to the ruby count method on arrays. --- lib/puppet/parser/functions/count.rb | 22 ++++++++++++++++++++ spec/unit/puppet/parser/functions/count_spec.rb | 27 +++++++++++++++++++++++++ 2 files changed, 49 insertions(+) create mode 100644 lib/puppet/parser/functions/count.rb create mode 100644 spec/unit/puppet/parser/functions/count_spec.rb diff --git a/lib/puppet/parser/functions/count.rb b/lib/puppet/parser/functions/count.rb new file mode 100644 index 0000000..52de1b8 --- /dev/null +++ b/lib/puppet/parser/functions/count.rb @@ -0,0 +1,22 @@ +module Puppet::Parser::Functions + newfunction(:count, :type => :rvalue, :arity => -2, :doc => <<-EOS +Takes an array as first argument and an optional second argument. +Count the number of elements in array that matches second argument. +If called with only an array it counts the number of elements that are not nil/undef. + EOS + ) do |args| + + if (args.size > 2) then + raise(ArgumentError, "count(): Wrong number of arguments "+ + "given #{args.size} for 1 or 2.") + end + + collection, item = args + + if item then + collection.count item + else + collection.count { |obj| obj != nil && obj != :undef && obj != '' } + end + end +end diff --git a/spec/unit/puppet/parser/functions/count_spec.rb b/spec/unit/puppet/parser/functions/count_spec.rb new file mode 100644 index 0000000..5e4a8b9 --- /dev/null +++ b/spec/unit/puppet/parser/functions/count_spec.rb @@ -0,0 +1,27 @@ +#! /usr/bin/env ruby -S rspec + +require 'spec_helper' + +describe "the count function" do + let(:scope) { PuppetlabsSpec::PuppetInternals.scope } + + it "should exist" do + Puppet::Parser::Functions.function("count").should == "function_count" + end + + it "should raise a ArgumentError if there is more than 2 arguments" do + lambda { scope.function_count(['foo', 'bar', 'baz']) }.should( raise_error(ArgumentError)) + end + + it "should be able to count arrays" do + scope.function_count([["1","2","3"]]).should(eq(3)) + end + + it "should be able to count matching elements in arrays" do + scope.function_count([["1", "2", "2"], "2"]).should(eq(2)) + end + + it "should not count :undef, nil or empty strings" do + scope.function_count([["foo","bar",:undef,nil,""]]).should(eq(2)) + end +end -- cgit v1.2.3 From 435226abfdf001bf2475be56d77027c638e93b70 Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Wed, 10 Apr 2013 14:33:08 -0700 Subject: (maint) Add the behavior for count() with arrays and hashes Without this patch the expected behavior of the count() function when dealing with an out of bound array index and with a hash key that does not exist is implicitly encoded in the spec examples. This is a problem because the expected behavior is not clear for something similar to the following example: node default { $ary = [ 1, 2, 3 ] $ary_undef = $ary[100] $hsh = { 'one' => 1 } $hsh_undef = $hsh['dne'] $count = count(['hi', $ary_undef, $hsh_undef]) notice "Count is ${count}" } This patch addresses the problem by making the expected behavior explicit in the examples. --- spec/unit/puppet/parser/functions/count_spec.rb | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/spec/unit/puppet/parser/functions/count_spec.rb b/spec/unit/puppet/parser/functions/count_spec.rb index 5e4a8b9..2453815 100644 --- a/spec/unit/puppet/parser/functions/count_spec.rb +++ b/spec/unit/puppet/parser/functions/count_spec.rb @@ -21,7 +21,11 @@ describe "the count function" do scope.function_count([["1", "2", "2"], "2"]).should(eq(2)) end - it "should not count :undef, nil or empty strings" do - scope.function_count([["foo","bar",:undef,nil,""]]).should(eq(2)) + it "should not count nil or empty strings" do + scope.function_count([["foo","bar",nil,""]]).should(eq(2)) + end + + it 'does not count an undefined hash key or an out of bound array index (which are both :undef)' do + expect(scope.function_count([["foo",:undef,:undef]])).to eq(1) end end -- cgit v1.2.3 From e81a45ee0085597dad5067cada94b05cf11c6c0c Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Wed, 10 Apr 2013 14:35:42 -0700 Subject: (maint) Make stdlib usable as a Ruby GEM Without this patch it is inconvenient to use the functions included in stdlib in a development setting. The Puppet modulepath must be explicitly set for the functions to be automatically loaded. This patch addresses the problem by adding a gem specification and dependency Gemfile. This makes it possible to directly use stdlib and all of the components it depends upon, like so: $ bundle install --path .bundle/gems/ $ bundle exec puppet apply -e 'notice count([1, 2, 3])' The first command will install all of the dependencies, including Puppet and Facter, into the local project directory. The second command will make stdlib avaialable as a Gem, which will be picked up by Puppet since (#7788) was merged into Puppet in the 3.0 release. --- .gemspec | 31 +++++++++++++++++++++++++++++++ Gemfile | 1 + 2 files changed, 32 insertions(+) create mode 100644 .gemspec diff --git a/.gemspec b/.gemspec new file mode 100644 index 0000000..805e170 --- /dev/null +++ b/.gemspec @@ -0,0 +1,31 @@ +# +# -*- encoding: utf-8 -*- + +Gem::Specification.new do |s| + s.name = "puppetmodule-stdlib" + + s.version = "3.2.0" + + s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= + s.authors = ["Puppet Labs"] + s.date = "2013-04-10" + s.description = "Puppet Labs Standard Library module" + s.email = "support@puppetlabs.com" + s.executables = [] + s.files = [] + s.homepage = "https://github.com/puppetlabs/puppetlabs-stdlib" + s.rdoc_options = ["--title", "Puppet Standard Library Module", "--main", "README.markdown", "--line-numbers"] + s.require_paths = ["lib"] + s.rubyforge_project = "puppetmodule_stdlib" + s.rubygems_version = "1.8.24" + s.summary = "This module provides a standard library of resources for developing Puppet Modules." + + if s.respond_to? :specification_version then + s.specification_version = 3 + + if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then + else + end + else + end +end diff --git a/Gemfile b/Gemfile index 1026074..442dd9d 100644 --- a/Gemfile +++ b/Gemfile @@ -6,6 +6,7 @@ end group :development, :test do gem 'rake' + gem 'puppetmodule-stdlib', ">= 1.0.0", :path => File.expand_path("..", __FILE__) gem 'rspec', "~> 2.11.0", :require => false gem 'mocha', "~> 0.10.5", :require => false gem 'puppetlabs_spec_helper', :require => false -- cgit v1.2.3 From 9c5805f26ac0abf8bf19cef1ac7a2fec19dec35b Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Thu, 11 Apr 2013 09:49:53 -0700 Subject: Add ability to use puppet from git via bundler Without this patch the Gemfile can only satisfy dependencies using officially release gem versions. This is a problem because we want to test stdlib against the latest HEAD of the puppet git repository. This patch addresses the problem by copying over the location_for method from the Puppet Gemfile, which will parse out git://, file:// or Gem version specifications. This, in turn, allows jobs to be configured to run with different dependency integrations. --- Gemfile | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/Gemfile b/Gemfile index 442dd9d..50df2ee 100644 --- a/Gemfile +++ b/Gemfile @@ -1,5 +1,16 @@ source "https://rubygems.org" +def location_for(place, fake_version = nil) + mdata = /^(git:[^#]*)#(.*)/.match(place) + if mdata + [fake_version, { :git => mdata[1], :branch => mdata[2], :require => false }].compact + elsif place =~ /^file:\/\/(.*)/ + ['>= 0', { :path => File.expand_path(mdata[1]), :require => false }] + else + [place, { :require => false }] + end +end + group :development do gem 'watchr' end @@ -14,7 +25,7 @@ group :development, :test do end if puppetversion = ENV['PUPPET_GEM_VERSION'] - gem 'puppet', puppetversion, :require => false + gem 'puppet', *location_for(puppetversion) else gem 'puppet', :require => false end -- cgit v1.2.3 From 25b670e6f6c52e84e28bbe4810f949b467a9b2d8 Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Thu, 11 Apr 2013 13:44:05 -0700 Subject: Update Modulefile, README, CHANGELOG for stdlib-4.0.0 --- CHANGELOG | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- Modulefile | 4 +-- README.markdown | 12 +++++++-- 3 files changed, 87 insertions(+), 6 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 313b83c..b704f52 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,5 +1,78 @@ -2012-11-28 - Peter Meier - 3.2.0 - * Add reject() function (a79b2cd) +2013-04-11 - Jeff McCune - 4.0.0 + * stdlib 4.0 drops support with Puppet 2.7 + * stdlib 4.0 preserves support with Puppet 3 + +2013-04-11 - Jeff McCune - 4.0.0 + * Add ability to use puppet from git via bundler (9c5805f) + +2013-04-10 - Jeff McCune - 4.0.0 + * (maint) Make stdlib usable as a Ruby GEM (e81a45e) + +2013-04-10 - Erik Dalén - 4.0.0 + * Add a count function (f28550e) + +2013-03-31 - Amos Shapira - 4.0.0 + * (#19998) Implement any2array (7a2fb80) + +2013-03-29 - Steve Huff - 4.0.0 + * (19864) num2bool match fix (8d217f0) + +2013-03-20 - Erik Dalén - 4.0.0 + * Allow comparisons of Numeric and number as String (ff5dd5d) + +2013-03-26 - Richard Soderberg - 4.0.0 + * add suffix function to accompany the prefix function (88a93ac) + +2013-03-19 - Kristof Willaert - 4.0.0 + * Add floor function implementation and unit tests (0527341) + +2012-04-03 - Eric Shamow - 4.0.0 + * (#13610) Add is_function_available to stdlib (961dcab) + +2012-12-17 - Justin Lambert - 4.0.0 + * str2bool should return a boolean if called with a boolean (5d5a4d4) + +2012-10-23 - Uwe Stuehler - 4.0.0 + * Fix number of arguments check in flatten() (e80207b) + +2013-03-11 - Jeff McCune - 4.0.0 + * Add contributing document (96e19d0) + +2013-03-04 - Raphaël Pinson - 4.0.0 + * Add missing documentation for validate_augeas and validate_cmd to README.markdown (a1510a1) + +2013-02-14 - Joshua Hoblitt - 4.0.0 + * (#19272) Add has_element() function (95cf3fe) + +2013-02-07 - Raphaël Pinson - 4.0.0 + * validate_cmd(): Use Puppet::Util::Execution.execute when available (69248df) + +2012-12-06 - Raphaël Pinson - 4.0.0 + * Add validate_augeas function (3a97c23) + +2012-12-06 - Raphaël Pinson - 4.0.0 + * Add validate_cmd function (6902cc5) + +2013-01-14 - David Schmitt - 4.0.0 + * Add geppetto project definition (b3fc0a3) + +2013-01-02 - Jaka Hudoklin - 4.0.0 + * Add getparam function to get defined resource parameters (20e0e07) + +2013-01-05 - Jeff McCune - 4.0.0 + * (maint) Add Travis CI Support (d082046) + +2012-12-04 - Jeff McCune - 4.0.0 + * Clarify that stdlib 3 supports Puppet 3 (3a6085f) + +2012-11-30 - Erik Dalén - 4.0.0 + * maint: style guideline fixes (7742e5f) + +2012-11-09 - James Fryman - 4.0.0 + * puppet-lint cleanup (88acc52) + +2012-11-06 - Joe Julian - 4.0.0 + * Add function, uriescape, to URI.escape strings. Redmine #17459 (fd52b8d) 2012-09-18 - Chad Metcalf - 3.2.0 * Add an ensure_packages function. (8a8c09e) diff --git a/Modulefile b/Modulefile index 34564fa..72a0b1b 100644 --- a/Modulefile +++ b/Modulefile @@ -1,6 +1,6 @@ name 'puppetlabs-stdlib' -version '3.2.0' -source 'git://github.com/puppetlabs/puppetlabs-stdlib' +version '4.0.0' +source 'git://github.com/puppetlabs/puppetlabs-stdlib.git' author 'puppetlabs' license 'Apache 2.0' summary 'Puppet Module Standard Library' diff --git a/README.markdown b/README.markdown index 336d0ab..9a1cdc0 100644 --- a/README.markdown +++ b/README.markdown @@ -28,9 +28,11 @@ older versions of Puppet Enterprise that Puppet Labs still supports will have bugfix maintenance branches periodically "merged up" into master. The current list of integration branches are: - * v2.1.x (v2.1.1 released in PE 1.2, 1.2.1, 1.2.3, 1.2.4) + * v2.1.x (v2.1.1 released in PE 1) * v2.2.x (Never released as part of PE, only to the Forge) - * v2.3.x (Released in PE 2.5.x) + * v2.3.x (Released in PE 2) + * v3.0.x (Never released as part of PE, only to the Forge) + * v4.0.x (Drops support for Puppet 2.7) * master (mainline development branch) The first Puppet Enterprise version including the stdlib module is Puppet @@ -50,6 +52,12 @@ All stdlib releases in the 2.0 major version support Puppet 2.6 and Puppet 2.7. The 3.0 major release of stdlib drops support for Puppet 2.6. Stdlib 3.x supports Puppet 2 and Puppet 3. +## stdlib 4.x ## + +The 4.0 major release of stdlib drops support for Puppet 2.7. Stdlib 4.x +supports Puppet 3. Notably, ruby 1.8.5 is no longer supported though ruby +1.8.7, 1.9.3, and 2.0.0 are fully supported. + # Functions # abs -- cgit v1.2.3 From ddfafc4a856d32185ef2318cf58341852bf58b29 Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Thu, 11 Apr 2013 14:04:31 -0700 Subject: Update function documentation for 4.0.0 Without this patch the function documentation is out of sync with the functions contained in the standard library. This commit updates the functions. I generated the list using this sequence: cd ~/src/puppet git checkout 3.1.1 bundle exec puppet doc -r function > /tmp/puppet_functions.txt cd ~/src/stdlib bundle exec puppet doc -r function > /tmp/stdlib_functions.txt diff -U2 puppet_functions.txt stdlib_functions.txt | grep '^+' | perl -ple 's/^\+//' > functions.txt I then replaced the README function documentation with the contents of functions.txt which contains only the functions contained in stdlib. --- README.markdown | 326 ++++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 271 insertions(+), 55 deletions(-) diff --git a/README.markdown b/README.markdown index 9a1cdc0..15a5516 100644 --- a/README.markdown +++ b/README.markdown @@ -62,8 +62,17 @@ supports Puppet 3. Notably, ruby 1.8.5 is no longer supported though ruby abs --- -Returns the absolute value of a number, for example -34.56 becomes 34.56. Takes -a single integer and float value as an argument. +Returns the absolute value of a number, for example -34.56 becomes +34.56. Takes a single integer and float value as an argument. + + +- *Type*: rvalue + +any2array +--------- +This converts any object to an array containing that object. Empty argument +lists are converted to an empty array. Arrays are left untouched. Hashes are +converted to arrays of alternating keys and values. - *Type*: rvalue @@ -88,9 +97,9 @@ Requires either a single string or an array as an input. chomp ----- -Removes the record separator from the end of a string or an array of strings, -for example `hello\n` becomes `hello`. Requires a single string or array as an -input. +Removes the record separator from the end of a string or an array of +strings, for example `hello\n` becomes `hello`. +Requires a single string or array as an input. - *Type*: rvalue @@ -107,8 +116,25 @@ Requires a string or array of strings as input. - *Type*: rvalue concat +------ +Appends the contents of array 2 onto array 1. + +*Example:* + + concat(['1','2','3'],['4','5','6']) + +Would result in: + + ['1','2','3','4','5','6'] + + +- *Type*: rvalue + +count ----- -Appends the contents of the second array onto the first array. +Takes an array as first argument and an optional second argument. +Count the number of elements in array that matches second argument. +If called with only an array it counts the number of elements that are not nil/undef. - *Type*: rvalue @@ -133,13 +159,19 @@ to the catalog, and false otherwise. delete ------ -Deletes a selected element from an array. +Deletes all instances of a given element from an array, substring from a +string, or key from a hash. *Examples:* - delete(['a','b','c'], 'b') + delete(['a','b','c','b'], 'b') + Would return: ['a','c'] -Would return: ['a','c'] + delete({'a'=>1,'b'=>2,'c'=>3}, 'b') + Would return: {'a'=>1,'c'=>3} + + delete('abracadabra', 'bra') + Would return: 'acada' - *Type*: rvalue @@ -171,6 +203,13 @@ Returns true if the variable is empty. - *Type*: rvalue +ensure_packages +--------------- +Takes a list of packages and only installs them if they don't already exist. + + +- *Type*: statement + ensure_resource --------------- Takes a resource type, title, and a list of attributes that describe a @@ -211,12 +250,6 @@ floor Returns the largest integer less or equal to the argument. Takes a single numeric value as an argument. -*Examples:* - - floor('3.8') - -Would return: '3' - - *Type*: rvalue @@ -240,11 +273,10 @@ Example: getparam -------- +Takes a resource reference and name of the parameter and +returns value of resource's parameter. -Takes a resource reference and name of the parameter and returns -value of resource's parameter. - -For example: +*Examples:* define example_resource($param) { } @@ -255,6 +287,9 @@ For example: getparam(Example_resource["example_resource_instance"], "param") +Would return: param_value + + - *Type*: rvalue getvar @@ -289,6 +324,44 @@ Would return: ['aaa','aaaddd'] +- *Type*: rvalue + +has_interface_with +------------------ +Returns boolean based on kind and value: +* macaddress +* netmask +* ipaddress +* network + +has_interface_with("macaddress", "x:x:x:x:x:x") +has_interface_with("ipaddress", "127.0.0.1") => true +etc. + +If no "kind" is given, then the presence of the interface is checked: +has_interface_with("lo") => true + + +- *Type*: rvalue + +has_ip_address +-------------- +Returns true if the client has the requested IP address on some interface. + +This function iterates through the 'interfaces' fact and checks the +'ipaddress_IFACE' facts, performing a simple string comparison. + + +- *Type*: rvalue + +has_ip_network +-------------- +Returns true if the client has an IP address within the requested network. + +This function iterates through the 'interfaces' fact and checks the +'network_IFACE' facts, performing a simple string comparision. + + - *Type*: rvalue has_key @@ -325,57 +398,39 @@ Would return: {'a'=>1,'b'=>2,'c'=>3} is_array -------- Returns true if the variable passed to this function is an array. - - - *Type*: rvalue - is_domain_name -------------- Returns true if the string passed to this function is a syntactically correct domain name. - - - *Type*: rvalue - is_float --------- Returns true if the variable passed to this function is a float. - - - *Type*: rvalue - +is_function_available +--------------------- +This function accepts a string as an argument, determines whether the +Puppet runtime has access to a function by that name. It returns a +true if the function exists, false if not. +- *Type*: rvalue is_hash ------- Returns true if the variable passed to this function is a hash. - - -- *Type*: rvalue - is_integer ---------- Returns true if the variable returned to this string is an integer. - - - *Type*: rvalue - is_ip_address ------------- Returns true if the string passed to this function is a valid IP address. - - - *Type*: rvalue - is_mac_address -------------- Returns true if the string passed to this function is a valid mac address. - - - *Type*: rvalue - is_numeric ---------- Returns true if the variable passed to this function is a number. - - *Type*: rvalue is_string @@ -396,6 +451,21 @@ This function joins an array into a string using a seperator. Would result in: "a,b,c" +- *Type*: rvalue + +join_keys_to_values +------------------- +This function joins each key of a hash to that key's corresponding value with a +separator. Keys and values are cast to strings. The return value is an array in +which each element is one joined key/value pair. + +*Examples:* + + join_keys_to_values({'a'=>1,'b'=>2}, " is ") + +Would result in: ["a is 1","b is 2"] + + - *Type*: rvalue keys @@ -422,6 +492,20 @@ lstrip Strips leading spaces to the left of a string. +- *Type*: rvalue + +max +--- +Returns the highest value of all arguments. +Requires at least one argument. + + +- *Type*: rvalue + +md5 +--- +Returns a MD5 hash value from a provided string. + - *Type*: rvalue member @@ -459,10 +543,25 @@ When there is a duplicate key, the key in the rightmost hash will "win." - *Type*: rvalue +min +--- +Returns the lowest value of all arguments. +Requires at least one argument. + + +- *Type*: rvalue + +notice +------ +Log a message on the server at level notice. + +- *Type*: statement + num2bool -------- -This function converts a number into a true boolean. Zero becomes false. Numbers -higher then 0 become true. +This function converts a number or a string representation of a number into a +true boolean. Zero or anything non-numeric becomes false. Numbers higher then 0 +become true. - *Type*: rvalue @@ -481,6 +580,25 @@ This function accepts YAML as a string and converts it into the correct Puppet structure. +- *Type*: rvalue + +pick +---- +This function is similar to a coalesce function in SQL in that it will return +the first value in a list of values that is not undefined or an empty string +(two things in Puppet that will return a boolean false value). Typically, +this function is used to check for a value in the Puppet Dashboard/Enterprise +Console, and failover to a default value like the following: + + $real_jenkins_version = pick($::jenkins_version, '1.449') + +The value of $real_jenkins_version will first look for a top-scope variable +called 'jenkins_version' (note that parameters set in the Puppet Dashboard/ +Enterprise Console are brought into Puppet as top-scope variables), and, +failing that, will use a default value of 1.449. + + + - *Type*: rvalue prefix @@ -523,6 +641,94 @@ Will return: ["host01", "host02", ..., "host09", "host10"] - *Type*: rvalue +realize +------- +Make a virtual object real. This is useful +when you want to know the name of the virtual object and don't want to +bother with a full collection. It is slightly faster than a collection, +and, of course, is a bit shorter. You must pass the object using a +reference; e.g.: `realize User[luke]`. + +- *Type*: statement + +regsubst +-------- +Perform regexp replacement on a string or array of strings. + +* *Parameters* (in order): + * _target_ The string or array of strings to operate on. If an array, the replacement will be performed on each of the elements in the array, and the return value will be an array. + * _regexp_ The regular expression matching the target string. If you want it anchored at the start and or end of the string, you must do that with ^ and $ yourself. + * _replacement_ Replacement string. Can contain backreferences to what was matched using \0 (whole match), \1 (first set of parentheses), and so on. + * _flags_ Optional. String of single letter flags for how the regexp is interpreted: + - *E* Extended regexps + - *I* Ignore case in regexps + - *M* Multiline regexps + - *G* Global replacement; all occurrences of the regexp in each target string will be replaced. Without this, only the first occurrence will be replaced. + * _encoding_ Optional. How to handle multibyte characters. A single-character string with the following values: + - *N* None + - *E* EUC + - *S* SJIS + - *U* UTF-8 + +* *Examples* + +Get the third octet from the node's IP address: + + $i3 = regsubst($ipaddress,'^(\d+)\.(\d+)\.(\d+)\.(\d+)$','\3') + +Put angle brackets around each octet in the node's IP address: + + $x = regsubst($ipaddress, '([0-9]+)', '<\1>', 'G') + + +- *Type*: rvalue + +reject +------ +This function searches through an array and rejects all elements that match +the provided regular expression. + +*Examples:* + + reject(['aaa','bbb','ccc','aaaddd'], 'aaa') + +Would return: + + ['bbb','ccc'] + + +- *Type*: rvalue + +require +------- +Evaluate one or more classes, adding the required class as a dependency. + +The relationship metaparameters work well for specifying relationships +between individual resources, but they can be clumsy for specifying +relationships between classes. This function is a superset of the +'include' function, adding a class relationship so that the requiring +class depends on the required class. + +Warning: using require in place of include can lead to unwanted dependency cycles. + +For instance the following manifest, with 'require' instead of 'include' would produce a nasty dependence cycle, because notify imposes a before between File[/foo] and Service[foo]: + + class myservice { + service { foo: ensure => running } + } + + class otherstuff { + include myservice + file { '/foo': notify => Service[foo] } + } + +Note that this function only works with clients 0.25 and later, and it will +fail if used with earlier clients. + + + +- *Type*: statement + reverse ------- Reverses the order of a string or array. @@ -537,6 +743,7 @@ Strips leading spaces to the right of the string. - *Type*: rvalue +search shuffle ------- Randomizes the order of a string or array elements. @@ -560,8 +767,7 @@ Sorts strings and arrays lexically. squeeze ------- -Returns a new string where runs of the same character that occur in this set -are replaced by a single character. +Returns a new string where runs of the same character that occur in this set are replaced by a single character. - *Type*: rvalue @@ -577,10 +783,10 @@ like: 0, f, n, false, no to 'false'. str2saltedsha512 ---------------- -This converts a string to a salted-SHA512 password hash (which is used for OS X -versions >= 10.7). Given any simple string, you will get a hex version of a -salted-SHA512 password hash that can be inserted into your Puppet manifests as -a valid password attribute. +This converts a string to a salted-SHA512 password hash (which is used for +OS X versions >= 10.7). Given any simple string, you will get a hex version +of a salted-SHA512 password hash that can be inserted into your Puppet +manifests as a valid password attribute. - *Type*: rvalue @@ -763,7 +969,15 @@ Converts a string or an array of strings to uppercase. Will return: - ABCD + ASDF + + +- *Type*: rvalue + +uriescape +--------- +Urlencodes a string or array of strings. +Requires either a single string or an array as an input. - *Type*: rvalue @@ -815,7 +1029,7 @@ The following values will fail, causing compilation to abort: - *Type*: statement validate_augeas --------------- +--------------- Perform validation of a string using an Augeas lens The first argument of this function should be a string to test, and the second argument should be the name of the Augeas lens to use. @@ -844,6 +1058,7 @@ A helpful error message can be returned like this: validate_augeas($sudoerscontent, 'Sudoers.lns', [], 'Failed to validate sudoers content with Augeas') + - *Type*: statement validate_bool @@ -868,9 +1083,8 @@ The following values will fail, causing compilation to abort: - *Type*: statement - validate_cmd -------------- +------------ Perform validation of a string with an external command. The first argument of this function should be a string to test, and the second argument should be a path to a test command @@ -1045,3 +1259,5 @@ Would result in: - *Type*: rvalue + +*This page autogenerated on 2013-04-11 13:54:25 -0700* -- cgit v1.2.3 From 475e29f69827c6e04c620955860617a30b523f4e Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Thu, 11 Apr 2013 14:14:02 -0700 Subject: Update gemspec for 4.0.0 --- .gemspec | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.gemspec b/.gemspec index 805e170..3e7f774 100644 --- a/.gemspec +++ b/.gemspec @@ -4,7 +4,7 @@ Gem::Specification.new do |s| s.name = "puppetmodule-stdlib" - s.version = "3.2.0" + s.version = "4.0.0" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.authors = ["Puppet Labs"] @@ -12,11 +12,14 @@ Gem::Specification.new do |s| s.description = "Puppet Labs Standard Library module" s.email = "support@puppetlabs.com" s.executables = [] - s.files = [] + s.files = [ 'CHANGELOG', 'CONTRIBUTING.md', 'Gemfile', 'LICENSE', 'Modulefile', + 'README.markdown', 'README_DEVELOPER.markdown', 'RELEASE_PROCESS.markdown', + 'Rakefile', 'spec/spec.opts' ] + s.files += Dir['lib/**/*.rb'] + Dir['manifests/**/*.pp'] + Dir['tests/**/*.pp'] + Dir['spec/**/*.rb'] s.homepage = "https://github.com/puppetlabs/puppetlabs-stdlib" s.rdoc_options = ["--title", "Puppet Standard Library Module", "--main", "README.markdown", "--line-numbers"] s.require_paths = ["lib"] - s.rubyforge_project = "puppetmodule_stdlib" + s.rubyforge_project = "puppetmodule-stdlib" s.rubygems_version = "1.8.24" s.summary = "This module provides a standard library of resources for developing Puppet Modules." -- cgit v1.2.3 From ab3e30c0251d28745bcf3820e06fd2ce948c08aa Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Thu, 11 Apr 2013 14:29:56 -0700 Subject: Fix README function documentation Without this patch some core puppet functions leaked into the documentation for the functions contained in stdlib. This patch removes them and cleans up some of the formatting. --- README.markdown | 132 +++++++++----------------------------------------------- 1 file changed, 21 insertions(+), 111 deletions(-) diff --git a/README.markdown b/README.markdown index 15a5516..fb6e585 100644 --- a/README.markdown +++ b/README.markdown @@ -398,35 +398,53 @@ Would return: {'a'=>1,'b'=>2,'c'=>3} is_array -------- Returns true if the variable passed to this function is an array. + - *Type*: rvalue + is_domain_name -------------- Returns true if the string passed to this function is a syntactically correct domain name. + - *Type*: rvalue + is_float +-------- Returns true if the variable passed to this function is a float. + - *Type*: rvalue + is_function_available --------------------- This function accepts a string as an argument, determines whether the Puppet runtime has access to a function by that name. It returns a true if the function exists, false if not. + - *Type*: rvalue + is_hash ------- Returns true if the variable passed to this function is a hash. + +- *Type*: rvalue + is_integer ---------- Returns true if the variable returned to this string is an integer. + - *Type*: rvalue + is_ip_address ------------- Returns true if the string passed to this function is a valid IP address. + - *Type*: rvalue + is_mac_address -------------- Returns true if the string passed to this function is a valid mac address. + - *Type*: rvalue + is_numeric ---------- Returns true if the variable passed to this function is a number. @@ -437,7 +455,6 @@ is_string --------- Returns true if the variable passed to this function is a string. - - *Type*: rvalue join @@ -450,7 +467,6 @@ This function joins an array into a string using a seperator. Would result in: "a,b,c" - - *Type*: rvalue join_keys_to_values @@ -465,14 +481,12 @@ which each element is one joined key/value pair. Would result in: ["a is 1","b is 2"] - - *Type*: rvalue keys ---- Returns the keys of a hash as an array. - - *Type*: rvalue loadyaml @@ -491,7 +505,6 @@ lstrip ------ Strips leading spaces to the left of a string. - - *Type*: rvalue max @@ -499,13 +512,6 @@ max Returns the highest value of all arguments. Requires at least one argument. - -- *Type*: rvalue - -md5 ---- -Returns a MD5 hash value from a provided string. - - *Type*: rvalue member @@ -522,7 +528,6 @@ Would return: true Would return: false - - *Type*: rvalue merge @@ -539,8 +544,6 @@ For example: When there is a duplicate key, the key in the rightmost hash will "win." - - - *Type*: rvalue min @@ -548,22 +551,14 @@ min Returns the lowest value of all arguments. Requires at least one argument. - - *Type*: rvalue -notice ------- -Log a message on the server at level notice. - -- *Type*: statement - num2bool -------- This function converts a number or a string representation of a number into a true boolean. Zero or anything non-numeric becomes false. Numbers higher then 0 become true. - - *Type*: rvalue parsejson @@ -571,7 +566,6 @@ parsejson This function accepts JSON as a string and converts into the correct Puppet structure. - - *Type*: rvalue parseyaml @@ -579,7 +573,6 @@ parseyaml This function accepts YAML as a string and converts it into the correct Puppet structure. - - *Type*: rvalue pick @@ -590,15 +583,13 @@ the first value in a list of values that is not undefined or an empty string this function is used to check for a value in the Puppet Dashboard/Enterprise Console, and failover to a default value like the following: - $real_jenkins_version = pick($::jenkins_version, '1.449') + $real_jenkins_version = pick($::jenkins_version, '1.449') The value of $real_jenkins_version will first look for a top-scope variable called 'jenkins_version' (note that parameters set in the Puppet Dashboard/ Enterprise Console are brought into Puppet as top-scope variables), and, failing that, will use a default value of 1.449. - - - *Type*: rvalue prefix @@ -611,7 +602,6 @@ This function applies a prefix to all elements in an array. Will return: ['pa','pb','pc'] - - *Type*: rvalue range @@ -638,49 +628,6 @@ Will return: ["a","b","c"] Will return: ["host01", "host02", ..., "host09", "host10"] - -- *Type*: rvalue - -realize -------- -Make a virtual object real. This is useful -when you want to know the name of the virtual object and don't want to -bother with a full collection. It is slightly faster than a collection, -and, of course, is a bit shorter. You must pass the object using a -reference; e.g.: `realize User[luke]`. - -- *Type*: statement - -regsubst --------- -Perform regexp replacement on a string or array of strings. - -* *Parameters* (in order): - * _target_ The string or array of strings to operate on. If an array, the replacement will be performed on each of the elements in the array, and the return value will be an array. - * _regexp_ The regular expression matching the target string. If you want it anchored at the start and or end of the string, you must do that with ^ and $ yourself. - * _replacement_ Replacement string. Can contain backreferences to what was matched using \0 (whole match), \1 (first set of parentheses), and so on. - * _flags_ Optional. String of single letter flags for how the regexp is interpreted: - - *E* Extended regexps - - *I* Ignore case in regexps - - *M* Multiline regexps - - *G* Global replacement; all occurrences of the regexp in each target string will be replaced. Without this, only the first occurrence will be replaced. - * _encoding_ Optional. How to handle multibyte characters. A single-character string with the following values: - - *N* None - - *E* EUC - - *S* SJIS - - *U* UTF-8 - -* *Examples* - -Get the third octet from the node's IP address: - - $i3 = regsubst($ipaddress,'^(\d+)\.(\d+)\.(\d+)\.(\d+)$','\3') - -Put angle brackets around each octet in the node's IP address: - - $x = regsubst($ipaddress, '([0-9]+)', '<\1>', 'G') - - - *Type*: rvalue reject @@ -699,76 +646,40 @@ Would return: - *Type*: rvalue -require -------- -Evaluate one or more classes, adding the required class as a dependency. - -The relationship metaparameters work well for specifying relationships -between individual resources, but they can be clumsy for specifying -relationships between classes. This function is a superset of the -'include' function, adding a class relationship so that the requiring -class depends on the required class. - -Warning: using require in place of include can lead to unwanted dependency cycles. - -For instance the following manifest, with 'require' instead of 'include' would produce a nasty dependence cycle, because notify imposes a before between File[/foo] and Service[foo]: - - class myservice { - service { foo: ensure => running } - } - - class otherstuff { - include myservice - file { '/foo': notify => Service[foo] } - } - -Note that this function only works with clients 0.25 and later, and it will -fail if used with earlier clients. - - - -- *Type*: statement - reverse ------- Reverses the order of a string or array. - - *Type*: rvalue rstrip ------ Strips leading spaces to the right of the string. - - *Type*: rvalue -search shuffle ------- Randomizes the order of a string or array elements. - - *Type*: rvalue size ---- Returns the number of elements in a string or array. - - *Type*: rvalue sort ---- Sorts strings and arrays lexically. - - *Type*: rvalue squeeze ------- -Returns a new string where runs of the same character that occur in this set are replaced by a single character. - +Returns a new string where runs of the same character that occur in this set +are replaced by a single character. - *Type*: rvalue @@ -1194,7 +1105,6 @@ The following values will fail, causing compilation to abort: validate_string($undefined) - - *Type*: statement values -- cgit v1.2.3 From 77b883cae18c03772f9827777444a8c999480b54 Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Thu, 11 Apr 2013 14:31:29 -0700 Subject: Update gemspec, CHANGELOG, Modulefile for 4.0.1 --- .gemspec | 2 +- CHANGELOG | 3 +++ Modulefile | 2 +- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/.gemspec b/.gemspec index 3e7f774..294e685 100644 --- a/.gemspec +++ b/.gemspec @@ -4,7 +4,7 @@ Gem::Specification.new do |s| s.name = "puppetmodule-stdlib" - s.version = "4.0.0" + s.version = "4.0.1" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.authors = ["Puppet Labs"] diff --git a/CHANGELOG b/CHANGELOG index b704f52..b4cd5e8 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2013-04-11 - Jeff McCune - 4.0.1 + * Fix README function documentation (ab3e30c) + 2013-04-11 - Jeff McCune - 4.0.0 * stdlib 4.0 drops support with Puppet 2.7 * stdlib 4.0 preserves support with Puppet 3 diff --git a/Modulefile b/Modulefile index 72a0b1b..ee48223 100644 --- a/Modulefile +++ b/Modulefile @@ -1,5 +1,5 @@ name 'puppetlabs-stdlib' -version '4.0.0' +version '4.0.1' source 'git://github.com/puppetlabs/puppetlabs-stdlib.git' author 'puppetlabs' license 'Apache 2.0' -- cgit v1.2.3 From a5c77921ae000dc837b31a41ea87b4bbf023c882 Mon Sep 17 00:00:00 2001 From: Chris Price Date: Fri, 13 Apr 2012 15:35:43 -0700 Subject: (#13695) add README about puppetlabs_spec_helper --- README_SPECS.markdown | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 README_SPECS.markdown diff --git a/README_SPECS.markdown b/README_SPECS.markdown new file mode 100644 index 0000000..917b631 --- /dev/null +++ b/README_SPECS.markdown @@ -0,0 +1,7 @@ +NOTE +==== + +This project's specs depend on puppet core, and thus they require the +`puppetlabs_spec_helper` project. For more information please see the README +in that project, which can be found here: [puppetlabs spec +helper](https://github.com/puppetlabs/puppetlabs_spec_helper) -- cgit v1.2.3 From ddad4455cc914862f16c2e8cae96812e244b0a1d Mon Sep 17 00:00:00 2001 From: Philip Potter Date: Thu, 12 Jul 2012 17:05:23 +0100 Subject: Make the anchor type propagate refresh events Without this patch the anchor resource does not propogate refresh events, making it difficult to subscribe to a class which has been notified by another resource. --- lib/puppet/type/anchor.rb | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/lib/puppet/type/anchor.rb b/lib/puppet/type/anchor.rb index 6b81732..fe1e5aa 100644 --- a/lib/puppet/type/anchor.rb +++ b/lib/puppet/type/anchor.rb @@ -38,4 +38,9 @@ Puppet::Type.newtype(:anchor) do desc "The name of the anchor resource." end + def refresh + # We don't do anything with them, but we need this to + # show that we are "refresh aware" and not break the + # chain of propagation. + end end -- cgit v1.2.3 From d2e692dce3794a57da78bb4624b182d1b379ae6a Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Thu, 11 Apr 2013 17:55:40 -0700 Subject: Add behavior example for anchor refresh propagation Without this patch we don't have a spec test to make sure the anchor resource type passes notify events along. This patch addresses the problem by using RSpec Puppet to build a catalog, apply the catalog, then pull a resource out of the transaction and make sure the resource was triggered. --- spec/classes/anchor_spec.rb | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 spec/classes/anchor_spec.rb diff --git a/spec/classes/anchor_spec.rb b/spec/classes/anchor_spec.rb new file mode 100644 index 0000000..2dd17de --- /dev/null +++ b/spec/classes/anchor_spec.rb @@ -0,0 +1,32 @@ +require 'puppet' +require 'rspec-puppet' + +describe "anchorrefresh" do + let(:node) { 'testhost.example.com' } + let :pre_condition do + <<-ANCHORCLASS +class anchored { + anchor { 'anchored::begin': } + ~> anchor { 'anchored::end': } +} + +class anchorrefresh { + notify { 'first': } + ~> class { 'anchored': } + ~> anchor { 'final': } +} + ANCHORCLASS + end + + def apply_catalog_and_return_exec_rsrc + catalog = subject.to_ral + transaction = catalog.apply + transaction.resource_status("Anchor[final]") + end + + it 'propagates events through the anchored class' do + resource = apply_catalog_and_return_exec_rsrc + + expect(resource.restarted).to eq(true) + end +end -- cgit v1.2.3 From 5a2d4c4a68f75a180804768e9504e1f4e3c9f9ae Mon Sep 17 00:00:00 2001 From: Garrett Honeycutt Date: Fri, 12 Apr 2013 13:04:15 +0200 Subject: adds compatibility matrix --- README.markdown | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.markdown b/README.markdown index fb6e585..0efaf16 100644 --- a/README.markdown +++ b/README.markdown @@ -40,6 +40,12 @@ Enterprise 1.2. # Compatibility # +Puppet Versions | < 2.6 | 2.6 | 2.7 | 3.x | +:---------------|:-----:|:---:|:---:|:----: +**stdlib 2.x** | no | **yes** | **yes** | no +**stdlib 3.x** | no | no | **yes** | **yes** +**stdlib 4.x** | no | no | no | **yes** + The stdlib module does not work with Puppet versions released prior to Puppet 2.6.0. -- cgit v1.2.3 From 5e0b90ed65b82cb3a88888b33262dec4fa32d975 Mon Sep 17 00:00:00 2001 From: Jeff McCune Date: Fri, 12 Apr 2013 09:23:34 -0700 Subject: Update gemspec, Modulefile, CHANGELOG for 4.0.2 Without this patch the information displayed on rubygems.org does not clearly convey the intent of the Gem format of stdlib from the official puppet module format of stdlib. This is a problem because end users might get confused and start installing stdlib from rubygems.org This patch addresses the problem by making it clear that the gem version of stdlib is not intended for end users, but rather is specifically intended to make it easier for other module authors to depend on stdlib and have that dependency automatically resolved using a Gemfile. [ci skip] --- .gemspec | 20 +++++++++++++------- CHANGELOG | 3 +++ Modulefile | 2 +- 3 files changed, 17 insertions(+), 8 deletions(-) diff --git a/.gemspec b/.gemspec index 294e685..e274950 100644 --- a/.gemspec +++ b/.gemspec @@ -4,24 +4,30 @@ Gem::Specification.new do |s| s.name = "puppetmodule-stdlib" - s.version = "4.0.1" + s.version = "4.0.2" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.authors = ["Puppet Labs"] - s.date = "2013-04-10" - s.description = "Puppet Labs Standard Library module" - s.email = "support@puppetlabs.com" + s.date = "2013-04-12" + s.description = [ 'This Gem format of the stdlib module is intended to make', + 'it easier for _module authors_ to resolve dependencies', + 'using a Gemfile when running automated testing jobs like', + 'Travis or Jenkins. The recommended best practice for', + 'installation by end users is to use the `puppet module', + 'install` command to install stdlib from the [Puppet', + 'Forge](http://forge.puppetlabs.com/puppetlabs/stdlib).' ].join(' ') + s.email = "puppet-dev@puppetlabs.com" s.executables = [] s.files = [ 'CHANGELOG', 'CONTRIBUTING.md', 'Gemfile', 'LICENSE', 'Modulefile', 'README.markdown', 'README_DEVELOPER.markdown', 'RELEASE_PROCESS.markdown', 'Rakefile', 'spec/spec.opts' ] s.files += Dir['lib/**/*.rb'] + Dir['manifests/**/*.pp'] + Dir['tests/**/*.pp'] + Dir['spec/**/*.rb'] - s.homepage = "https://github.com/puppetlabs/puppetlabs-stdlib" - s.rdoc_options = ["--title", "Puppet Standard Library Module", "--main", "README.markdown", "--line-numbers"] + s.homepage = "http://forge.puppetlabs.com/puppetlabs/stdlib" + s.rdoc_options = ["--title", "Puppet Standard Library Development Gem", "--main", "README.markdown", "--line-numbers"] s.require_paths = ["lib"] s.rubyforge_project = "puppetmodule-stdlib" s.rubygems_version = "1.8.24" - s.summary = "This module provides a standard library of resources for developing Puppet Modules." + s.summary = "This gem provides a way to make the standard library available for other module spec testing tasks." if s.respond_to? :specification_version then s.specification_version = 3 diff --git a/CHANGELOG b/CHANGELOG index b4cd5e8..26c942e 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2013-04-12 - Jeff McCune - 4.0.2 + * Update user information in gemspec to make the intent of the Gem clear. + 2013-04-11 - Jeff McCune - 4.0.1 * Fix README function documentation (ab3e30c) diff --git a/Modulefile b/Modulefile index ee48223..74304e5 100644 --- a/Modulefile +++ b/Modulefile @@ -1,5 +1,5 @@ name 'puppetlabs-stdlib' -version '4.0.1' +version '4.0.2' source 'git://github.com/puppetlabs/puppetlabs-stdlib.git' author 'puppetlabs' license 'Apache 2.0' -- cgit v1.2.3