diff --git a/Guardfile b/Guardfile
index fd50602..d007cdc 100644
--- a/Guardfile
+++ b/Guardfile
@@ -1,5 +1,5 @@
 notification :off
 
-guard 'rake', :task => 'test' do
+guard 'rake', task: 'test' do
   watch(%r{^manifests\/(.+)\.pp$})
 end
diff --git a/spec/acceptance/class_spec.rb b/spec/acceptance/class_spec.rb
index 2b7a6c5..0ef9c4c 100644
--- a/spec/acceptance/class_spec.rb
+++ b/spec/acceptance/class_spec.rb
@@ -1,30 +1,30 @@
 require 'spec_helper_acceptance'
 
 describe 'munin and munin-node' do
   context 'default parameters' do
     # Using puppet_apply as a helper
     it 'works idempotently with no errors' do
       pp = <<-PUPPET_CODE
       class { 'munin::master': }
       class { 'munin::node': }
       PUPPET_CODE
 
       # Run it twice and test for idempotency
-      apply_manifest(pp, :catch_failures => true)
-      apply_manifest(pp, :catch_changes  => true)
+      apply_manifest(pp, catch_failures: true)
+      apply_manifest(pp, catch_changes: true)
     end
 
     describe package('munin') do
       it { is_expected.to be_installed }
     end
 
     describe package('munin-node') do
       it { is_expected.to be_installed }
     end
 
     describe service('munin-node') do
       it { is_expected.to be_enabled }
       it { is_expected.to be_running }
     end
   end
 end
diff --git a/spec/acceptance/munin__master_spec.rb b/spec/acceptance/munin__master_spec.rb
index 53af5fa..082abf4 100644
--- a/spec/acceptance/munin__master_spec.rb
+++ b/spec/acceptance/munin__master_spec.rb
@@ -1,20 +1,20 @@
 require 'spec_helper_acceptance'
 
 describe 'munin::master class' do
   context 'default parameters' do
     # Using puppet_apply as a helper
     it 'works idempotently with no errors' do
       pp = <<-PUPPET_CODE
       class { 'munin::master': }
       PUPPET_CODE
 
       # Run it twice and test for idempotency
-      apply_manifest(pp, :catch_failures => true)
-      apply_manifest(pp, :catch_changes  => true)
+      apply_manifest(pp, catch_failures: true)
+      apply_manifest(pp, catch_changes: true)
     end
 
     describe package('munin') do
       it { is_expected.to be_installed }
     end
   end
 end
diff --git a/spec/acceptance/munin__node_spec.rb b/spec/acceptance/munin__node_spec.rb
index 8e2c965..5cab9b2 100644
--- a/spec/acceptance/munin__node_spec.rb
+++ b/spec/acceptance/munin__node_spec.rb
@@ -1,25 +1,25 @@
 require 'spec_helper_acceptance'
 
 describe 'munin::node class' do
   context 'default parameters' do
     # Using puppet_apply as a helper
     it 'works idempotently with no errors' do
       pp = <<-PUPPET_CODE
         class { 'munin::node': }
       PUPPET_CODE
 
       # Run it twice and test for idempotency
-      apply_manifest(pp, :catch_failures => true)
-      apply_manifest(pp, :catch_changes  => true)
+      apply_manifest(pp, catch_failures: true)
+      apply_manifest(pp, catch_changes: true)
     end
 
     describe package('munin-node') do
       it { is_expected.to be_installed }
     end
 
     describe service('munin-node') do
       it { is_expected.to be_enabled }
       it { is_expected.to be_running }
     end
   end
 end
diff --git a/spec/classes/munin_master_spec.rb b/spec/classes/munin_master_spec.rb
index 71eca7b..ad37e80 100644
--- a/spec/classes/munin_master_spec.rb
+++ b/spec/classes/munin_master_spec.rb
@@ -1,196 +1,196 @@
 require 'spec_helper'
 
 _conf_dir = {}
 _conf_dir.default = '/etc/munin'
 _conf_dir['Solaris'] = '/opt/local/etc/munin'
 _conf_dir['FreeBSD'] = '/usr/local/etc/munin'
 
 _package = {}
 _package.default = 'munin'
 _package['FreeBSD'] = 'munin-master'
 
 describe 'munin::master' do
   on_supported_os.each do |os, facts|
     # Avoid testing on distributions similar to RedHat and Debian
-    next if os =~ /^(ubuntu|centos|scientific|oraclelinux)-/
+    next if os =~ %r{^(ubuntu|centos|scientific|oraclelinux)-}
 
     # No need to test all os versions as long as os version is not
     # used in the params class
-    next if os =~ /^(debian-[67]|redhat-[56]|freebsd-9)-/
+    next if os =~ %r{^(debian-[67]|redhat-[56]|freebsd-9)-}
 
     context "on #{os}" do
       let(:facts) do
         facts
       end
 
       conf_dir = _conf_dir[facts[:osfamily]]
       package = _package[facts[:osfamily]]
 
       it { is_expected.to compile.with_all_deps }
 
       it { is_expected.to contain_package(package) }
 
       context 'with default params' do
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/graph_strategy\s+cgi/)
-            .with_content(/html_strategy\s+cgi/)
+            .with_content(%r{graph_strategy\s+cgi})
+            .with_content(%r{html_strategy\s+cgi})
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/munin-conf.d")
             .with_ensure('directory')
         end
       end
 
       context 'with html_strategy => cron' do
-        let (:params) { { :html_strategy => 'cron' } }
+        let (:params) { { html_strategy: 'cron' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/html_strategy\s+cron/)
+            .with_content(%r{html_strategy\s+cron})
         end
       end
 
       context 'with graph_strategy => cron' do
-        let (:params) { { :graph_strategy => 'cron' } }
+        let (:params) { { graph_strategy: 'cron' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/graph_strategy\s+cron/)
+            .with_content(%r{graph_strategy\s+cron})
         end
       end
 
       context 'with dbdir => /var/lib/munin' do
-        let (:params) { { :dbdir => '/var/lib/munin' } }
+        let (:params) { { dbdir: '/var/lib/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(/dbdir\s+\/var\/lib\/munin/)
         end
       end
 
       context 'with htmldir => /var/www/munin' do
-        let (:params) { { :htmldir => '/var/www/munin' } }
+        let (:params) { { htmldir: '/var/www/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(/htmldir\s+\/var\/www\/munin/)
         end
       end
 
       context 'with logdir => /var/log/munin' do
-        let (:params) { { :dbdir => '/var/log/munin' } }
+        let (:params) { { dbdir: '/var/log/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(/dbdir\s+\/var\/log\/munin/)
         end
       end
 
       context 'with rundir => /var/run/munin' do
-        let (:params) { { :dbdir => '/var/run/munin' } }
+        let (:params) { { dbdir: '/var/run/munin' } }
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
             .with_content(/dbdir\s+\/var\/run\/munin/)
         end
       end
 
       context 'with tls => enabled' do
         let(:params) do
           {
-            :tls => 'enabled',
-            :tls_certificate => '/path/to/certificate.pem',
-            :tls_private_key => '/path/to/key.pem',
-            :tls_verify_certificate => 'yes',
+            tls: 'enabled',
+            tls_certificate: '/path/to/certificate.pem',
+            tls_private_key: '/path/to/key.pem',
+            tls_verify_certificate: 'yes',
           }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/tls = enabled/)
+            .with_content(%r{tls = enabled})
             .with_content(/tls_certificate = \/path\/to\/certificate\.pem/)
             .with_content(/tls_private_key = \/path\/to\/key\.pem/)
-            .with_content(/tls_verify_certificate = yes/)
+            .with_content(%r{tls_verify_certificate = yes})
         end
       end
 
       context 'with node_definitions' do
         let(:params) do
           {
-            :node_definitions => {
+            node_definitions: {
               'node-a' => {
                 'address' => 'munin://node-a.example.com',
               },
               'node-b' => {
                 'address' => 'munin://node-b.example.com',
-              }
-            }
+              },
+            },
           }
         end
 
         it { is_expected.to compile.with_all_deps }
         it { is_expected.to contain_munin__master__node_definition('node-a') }
         it { is_expected.to contain_munin__master__node_definition('node-b') }
       end
 
       context 'with extra_config' do
         token = '1b7febce-bb2d-4c18-b889-84c73538a900'
         let(:params) do
-          { :extra_config => [token] }
+          { extra_config: [token] }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file("#{conf_dir}/munin.conf")
-            .with_content(/#{token}/)
+            .with_content(%r{#{token}})
         end
       end
 
       context 'with extra_config set to a string' do
         token = '1b7febce-bb2d-4c18-b889-84c73538a900'
         let(:params) do
-          { :extra_config => token }
+          { extra_config: token }
         end
 
-        it { is_expected.to raise_error(Puppet::Error, /is not an Array/) }
+        it { is_expected.to raise_error(Puppet::Error, %r{is not an Array}) }
       end
 
       ['test.example.com', 'invalid/hostname.example.com'].each do |param|
         context "with host_name => #{param}" do
           let(:params) do
-            { :host_name => param }
+            { host_name: param }
           end
 
-          if param =~ /invalid/
-            it { is_expected.to raise_error(Puppet::Error, /valid domain name/) }
+          if param =~ %r{invalid}
+            it { is_expected.to raise_error(Puppet::Error, %r{valid domain name}) }
           else
             it { is_expected.to compile.with_all_deps }
           end
         end
       end
 
-      %w(enabled disabled mine unclaimed invalid).each do |param|
+      %w[enabled disabled mine unclaimed invalid].each do |param|
         context "with collect_nodes => #{param}" do
           let(:params) do
-            { :collect_nodes => param }
+            { collect_nodes: param }
           end
 
           if param == 'invalid'
-            it { is_expected.to raise_error(Puppet::Error, /validate_re/) }
+            it { is_expected.to raise_error(Puppet::Error, %r{validate_re}) }
           else
             it { is_expected.to compile.with_all_deps }
           end
         end
       end
     end
   end
 end
diff --git a/spec/classes/munin_node_export_spec.rb b/spec/classes/munin_node_export_spec.rb
index 3afdf5c..a825882 100644
--- a/spec/classes/munin_node_export_spec.rb
+++ b/spec/classes/munin_node_export_spec.rb
@@ -1,65 +1,65 @@
 require 'spec_helper'
 
 _params = {
-  :address => '127.0.0.2',
-  :fqn => 'example;foo.example.com',
-  :masterconfig => [],
-  :mastername => 'munin.example.com'
+  address: '127.0.0.2',
+  fqn: 'example;foo.example.com',
+  masterconfig: [],
+  mastername: 'munin.example.com',
 }
 _extra_nodes = {
   'example;svc10.example.com' => {
     'address' => '127.0.0.10',
     'config'  => [],
   },
   'example;svc11.example.com' => {
     'address' => '127.0.0.11',
     'config'  => ['env foo.warn 12'],
-  }
+  },
 }
 
 describe 'munin::node::export' do
   on_supported_os.each do |os, facts|
     context "on #{os}" do
       let(:facts) { facts }
       let(:params) { _params }
 
       it { is_expected.to compile.with_all_deps }
 
       it do
         expect(exported_resources).to have_munin__master__node_definition_resource_count(1)
       end
       it do
         expect(exported_resources).to contain_munin__master__node_definition(_params[:fqn])
           .with_address(_params[:address])
           .with_mastername(_params[:mastername])
           .with_tag(["munin::master::#{_params[:mastername]}"])
       end
     end
 
     context "on #{os} with extra nodes" do
       let(:facts) { facts }
-      let(:params) { _params.merge({ :node_definitions => _extra_nodes }) }
+      let(:params) { _params.merge(node_definitions: _extra_nodes) }
 
       it { is_expected.to compile.with_all_deps }
 
       it do
         expect(exported_resources).to have_munin__master__node_definition_resource_count(3)
       end
       it do
         expect(exported_resources).to contain_munin__master__node_definition(_params[:fqn])
           .with_address(_params[:address])
           .with_mastername(_params[:mastername])
           .with_tag("munin::master::#{_params[:mastername]}")
       end
       _extra_nodes.each_key do |n|
         it do
           expect(exported_resources).to contain_munin__master__node_definition(n)
             .with_address(_extra_nodes[n]['address'])
             .with_mastername(_params[:mastername])
             .with_config(_extra_nodes[n]['config'])
             .with_tag("munin::master::#{_params[:mastername]}")
         end
       end
     end
   end
 end
diff --git a/spec/classes/munin_node_spec.rb b/spec/classes/munin_node_spec.rb
index f34193a..1604b87 100644
--- a/spec/classes/munin_node_spec.rb
+++ b/spec/classes/munin_node_spec.rb
@@ -1,186 +1,186 @@
 require 'spec_helper'
 
 _conf_dir = {}
 _conf_dir.default = '/etc/munin'
 _conf_dir['DragonFly'] = '/usr/local/etc/munin'
 _conf_dir['FreeBSD'] = '/usr/local/etc/munin'
 _conf_dir['Solaris'] = '/opt/local/etc/munin'
 
 describe 'munin::node' do
   on_supported_os.each do |os, facts|
     # Avoid testing on distributions similar to RedHat and Debian
-    next if os =~ /^(ubuntu|centos|scientific|oraclelinux)-/
+    next if os =~ %r{^(ubuntu|centos|scientific|oraclelinux)-}
 
     # No need to test all os versions as long as os version is not
     # used in the params class
-    next if os =~ /^(debian-[67]|redhat-[56]|freebsd-9)-/
+    next if os =~ %r{^(debian-[67]|redhat-[56]|freebsd-9)-}
 
     context "on #{os}" do
       let(:facts) { facts }
 
       it { is_expected.to compile.with_all_deps }
 
       it { is_expected.to contain_package('munin-node') }
 
       munin_confdir = _conf_dir[facts[:osfamily]]
 
       munin_node_conf = "#{munin_confdir}/munin-node.conf"
       munin_plugin_dir = "#{munin_confdir}/plugins"
       munin_plugin_conf_dir = "#{munin_confdir}/plugin-conf.d"
 
       munin_node_service =
         case facts[:osfamily]
         when 'Solaris' then 'smf:/munin-node'
         else 'munin-node'
         end
 
       log_dir =
         case facts[:osfamily]
         when 'Solaris' then '/var/opt/log/munin'
         when 'RedHat' then '/var/log/munin-node'
         else '/var/log/munin'
         end
 
       it { is_expected.to contain_service(munin_node_service) }
       it { is_expected.to contain_file(munin_node_conf) }
 
       context 'with no parameters' do
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_service(munin_node_service)
-            .without_ensure()
+            .without_ensure
         end
         it do
           is_expected.to contain_file(munin_node_conf)
-            .with_content(/host_name\s+foo.example.com/)
+            .with_content(%r{host_name\s+foo.example.com})
             .with_content(/log_file\s+#{log_dir}\/munin-node.log/)
         end
       end
 
       context 'with parameter allow' do
         let(:params) do
           { allow: ['2001:db8:1::',
                     '2001:db8:2::/64',
                     '192.0.2.129',
                     '192.0.2.0/25',
                     '192\.0\.2'] }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file(munin_node_conf)
             .with_content(/^cidr_allow 192.0.2.0\/25$/)
             .with_content(/^cidr_allow 2001:db8:2::\/64$/)
-            .with_content(/^allow \^192\\.0\\.2\\.129\$$/)
-            .with_content(/^allow 192\\.0\\.2$/)
-            .with_content(/^allow \^2001:db8:1::\$$/)
+            .with_content(%r{^allow \^192\\.0\\.2\\.129\$$})
+            .with_content(%r{^allow 192\\.0\\.2$})
+            .with_content(%r{^allow \^2001:db8:1::\$$})
         end
       end
 
       context 'with parameter host_name' do
         let(:params) do
           { host_name: 'something.example.com' }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_file(munin_node_conf)
-            .with_content(/host_name\s+something.example.com/)
+            .with_content(%r{host_name\s+something.example.com})
         end
       end
 
       context 'with parameter service_ensure' do
         let(:params) do
           { service_ensure: 'running' }
         end
 
         it { is_expected.to compile.with_all_deps }
         it do
           is_expected.to contain_service('munin-node')
             .with_ensure('running')
         end
       end
 
       context 'logging to syslog' do
         context 'defaults' do
           let(:params) do
             { log_destination: 'syslog' }
           end
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
-              .with_content(/log_file\s+Sys::Syslog/)
+              .with_content(%r{log_file\s+Sys::Syslog})
           end
         end
 
         context 'with syslog options' do
           let(:params) do
             { log_destination: 'syslog',
-              syslog_facility: 'local1', }
+              syslog_facility: 'local1' }
           end
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
-              .with_content(/log_file\s+Sys::Syslog/)
-              .with_content(/syslog_facility\s+local1/)
+              .with_content(%r{log_file\s+Sys::Syslog})
+              .with_content(%r{syslog_facility\s+local1})
           end
         end
 
         context 'with syslog_facility set to wrong value ' do
           let(:params) do
             { log_destination: 'syslog',
-              syslog_facility: 'wrong', }
+              syslog_facility: 'wrong' }
           end
 
-          it { expect { is_expected.to compile.with_all_deps }.to raise_error(/validate_re/) }
+          it { expect { is_expected.to compile.with_all_deps }.to raise_error(%r{validate_re}) }
         end
       end
 
       context 'purge_configs' do
         context 'set' do
           let(:params) { { purge_configs: true } }
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_plugin_dir)
               .with_ensure('directory')
               .with_recurse(true)
               .with_purge(true)
           end
           it do
             is_expected.to contain_file(munin_plugin_conf_dir)
               .with_ensure('directory')
               .with_recurse(true)
               .with_purge(true)
           end
         end
         context 'unset' do
           it { is_expected.to compile.with_all_deps }
           it { is_expected.not_to contain_file(munin_plugin_dir) }
           it { is_expected.not_to contain_file(munin_plugin_conf_dir) }
         end
       end
 
       context 'timeout' do
         context 'set' do
           let(:params) { { timeout: 123 } }
 
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
-              .with_content(/^timeout 123/)
+              .with_content(%r{^timeout 123})
           end
         end
         context 'unset' do
           it { is_expected.to compile.with_all_deps }
           it do
             is_expected.to contain_file(munin_node_conf)
-              .without_content(/^timeout/)
+              .without_content(%r{^timeout})
           end
         end
       end
     end
   end
 end
diff --git a/spec/defines/munin_plugin_spec.rb b/spec/defines/munin_plugin_spec.rb
index 19f9a1c..6354fc4 100644
--- a/spec/defines/munin_plugin_spec.rb
+++ b/spec/defines/munin_plugin_spec.rb
@@ -1,142 +1,142 @@
 require 'spec_helper'
 
 _conf_dir = {}
 _conf_dir.default = '/etc/munin'
 _conf_dir['Solaris'] = '/opt/local/etc/munin'
 _conf_dir['FreeBSD'] = '/usr/local/etc/munin'
 
 _share_dir = {}
 _share_dir.default = '/usr/share/munin'
 _share_dir['Solaris'] = '/opt/local/share/munin'
 _share_dir['FreeBSD'] = '/usr/local/share/munin'
 
-describe 'munin::plugin', :type => 'define' do
+describe 'munin::plugin', type: 'define' do
   let(:title) { 'testplugin' }
 
   on_supported_os.each do |os, facts|
     # Avoid testing on distributions similar to RedHat and Debian
-    next if os =~ /^(ubuntu|centos|scientific|oraclelinux)-/
+    next if os =~ %r{^(ubuntu|centos|scientific|oraclelinux)-}
 
     # No need to test all os versions as long as os version is not
     # used in the params class
-    next if os =~ /^(debian-[67]|redhat-[56]|freebsd-9)-/
+    next if os =~ %r{^(debian-[67]|redhat-[56]|freebsd-9)-}
 
     context "on #{os}" do
       let(:facts) do
         facts
       end
 
       conf_dir = _conf_dir[facts[:osfamily]]
       plugin_share_dir = "#{_share_dir[facts[:osfamily]]}/plugins"
 
       context 'with no parameters' do
         it do
           expect { is_expected.to contain_file("#{conf_dir}/plugins/testplugin") }
             .to raise_error("expected that the catalogue would contain File[#{conf_dir}/plugins/testplugin]")
         end
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/testplugin.conf")
             .with_ensure('absent')
         end
       end
 
       context 'with ensure=link parameter' do
-        let(:params) { { :ensure => 'link' } }
+        let(:params) { { ensure: 'link' } }
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugins/testplugin")
             .with_ensure('link')
             .with_target("#{plugin_share_dir}/testplugin")
         end
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/testplugin.conf")
             .with_ensure('absent')
         end
       end
 
       context 'with ensure=link and target parameters' do
         let(:title) { 'test_foo' }
         let(:params) do
-          { :ensure => 'link',
-            :target => 'test_' }
+          { ensure: 'link',
+            target: 'test_' }
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugins/test_foo")
             .with_ensure('link')
             .with_target("#{plugin_share_dir}/test_")
         end
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/test_foo.conf")
             .with_ensure('absent')
         end
       end
 
       context 'with ensure=present and source parameters' do
         let(:params) do
-          { :ensure => 'present',
-            :source => 'puppet:///modules/munin/plugins/testplugin' }
+          { ensure: 'present',
+            source: 'puppet:///modules/munin/plugins/testplugin' }
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugins/testplugin")
             .with_ensure('present')
             .with_source('puppet:///modules/munin/plugins/testplugin')
         end
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/testplugin.conf")
             .with_ensure('absent')
         end
       end
 
       context 'with ensure=present, source and config parameters' do
         let(:params) do
-          { :ensure => 'present',
-            :source => 'puppet:///modules/munin/plugins/testplugin',
-            :config => ['something wonderful'], }
+          { ensure: 'present',
+            source: 'puppet:///modules/munin/plugins/testplugin',
+            config: ['something wonderful'] }
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugins/testplugin")
             .with_ensure('present')
             .with_source('puppet:///modules/munin/plugins/testplugin')
         end
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/testplugin.conf")
             .with_ensure('present')
-            .with_content(/something wonderful/)
+            .with_content(%r{something wonderful})
         end
       end
 
       context 'only configuration' do
         let(:params) do
-          { :config => ['env.rootdn cn=admin,dc=example,dc=org'],
-            :config_label => 'slapd_*', }
+          { config: ['env.rootdn cn=admin,dc=example,dc=org'],
+            config_label: 'slapd_*' }
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/testplugin.conf")
             .with_ensure('present')
-            .with_content(/env.rootdn/)
+            .with_content(%r{env.rootdn})
         end
         it do
           expect { is_expected.to contain_file("#{conf_dir}/plugins/testplugin") }
             .to raise_error("expected that the catalogue would contain File[#{conf_dir}/plugins/testplugin]")
         end
       end
 
       context 'with absolute target' do
         let(:params) do
           { ensure: 'link',
             target: '/full/path/to/testplugin' }
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugins/testplugin")
             .with_ensure('link')
             .with_target('/full/path/to/testplugin')
         end
       end
     end
   end
 end
diff --git a/spec/defines/regression_13_munin_plugin_config_name_spec.rb b/spec/defines/regression_13_munin_plugin_config_name_spec.rb
index 03af49a..a367dd8 100644
--- a/spec/defines/regression_13_munin_plugin_config_name_spec.rb
+++ b/spec/defines/regression_13_munin_plugin_config_name_spec.rb
@@ -1,47 +1,47 @@
 require 'spec_helper'
 
 _conf_dir = {}
 _conf_dir.default = '/etc/munin'
 _conf_dir['Solaris'] = '/opt/local/etc/munin'
 _conf_dir['FreeBSD'] = '/usr/local/etc/munin'
 
 describe 'munin::plugin' do
   let(:title) { 'testplugin' }
 
   on_supported_os.each do |os, facts|
     # Avoid testing on distributions similar to RedHat and Debian
-    next if os =~ /^(ubuntu|centos|scientific|oraclelinux)-/
+    next if os =~ %r{^(ubuntu|centos|scientific|oraclelinux)-}
 
     # No need to test all os versions as long as os version is not
     # used in the params class
-    next if os =~ /^(debian-[67]|redhat-[56]|freebsd-9)-/
+    next if os =~ %r{^(debian-[67]|redhat-[56]|freebsd-9)-}
 
     context "on #{os}" do
       let(:facts) { facts }
 
       conf_dir = _conf_dir[facts[:osfamily]]
 
       context 'with config_label unset, label should be set to title' do
         let(:params) do
           { config: ['env.foo bar'] }
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/testplugin.conf")
-            .with_content(/^\[testplugin\]$/)
+            .with_content(%r{^\[testplugin\]$})
         end
       end
 
       context 'with config_label set, label should be set to config_label' do
         let(:params) do
           { config: ['env.foo bar'], config_label: 'foo_' }
         end
 
         it do
           is_expected.to contain_file("#{conf_dir}/plugin-conf.d/testplugin.conf")
-            .with_content(/^\[foo_\]$/)
+            .with_content(%r{^\[foo_\]$})
         end
       end
     end
   end
 end
diff --git a/spec/spec_helper_acceptance.rb b/spec/spec_helper_acceptance.rb
index 7929a70..9740985 100644
--- a/spec/spec_helper_acceptance.rb
+++ b/spec/spec_helper_acceptance.rb
@@ -1,22 +1,22 @@
 require 'beaker-rspec/spec_helper'
 require 'beaker-rspec/helpers/serverspec'
 require 'beaker/puppet_install_helper'
 
 run_puppet_install_helper unless ENV['BEAKER_provision'] == 'no'
 
 RSpec.configure do |c|
   # Project root
   proj_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 
   # Readable test descriptions
   c.formatter = :documentation
 
   # Configure all nodes in nodeset
   c.before :suite do
     # Install module and dependencies
-    puppet_module_install(:source => proj_root, :module_name => 'munin')
+    puppet_module_install(source: proj_root, module_name: 'munin')
     hosts.each do |host|
-      on host, puppet('module', 'install', 'puppetlabs-stdlib'), { :acceptable_exit_codes => [0, 1] }
+      on host, puppet('module', 'install', 'puppetlabs-stdlib'), acceptable_exit_codes: [0, 1]
     end
   end
 end