puppet-lint 2.3.0 → 2.3.1

data/spec/puppet-lint/plugins/check_strings/double_quoted_strings_spec.rb

@@ -41,7 +41,7 @@ describe 'double_quoted_strings' do
     end
 
     context 'double quoted string containing newline but no variables' do
-      let(:code) { %{"foo\n"} }
+      let(:code) { %("foo\n") }
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -49,18 +49,20 @@ describe 'double_quoted_strings' do
     end
 
     context 'double quoted string with backslash for continuation' do
-      let(:code) { %{
-        class puppet::master::maintenance (
-        ) {
-          cron { 'puppet_master_reports_cleanup':
-            command     => "/usr/bin/find /var/lib/puppet/reports -type f -mtime +15 \
-                           -delete && /usr/bin/find /var/lib/puppet/reports -mindepth 1 \
-                           -empty -type d -delete",
-            minute      => '15',
-            hour        => '5',
+      let(:code) do
+        <<-END
+          class puppet::master::maintenance (
+          ) {
+            cron { 'puppet_master_reports_cleanup':
+              command     => "/usr/bin/find /var/lib/puppet/reports -type f -mtime +15 \
+                             -delete && /usr/bin/find /var/lib/puppet/reports -mindepth 1 \
+                             -empty -type d -delete",
+              minute      => '15',
+              hour        => '5',
+            }
           }
-        }
-      } }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -92,15 +94,17 @@ describe 'double_quoted_strings' do
     end
 
     context 'double quoted stings containing supported escape patterns' do
-      let(:code) {%{
-        $string1 = "this string contins \n newline"
-        $string2 = "this string contains \ttab"
-        $string3 = "this string contains \${escaped} var"
-        $string4 = "this string contains \\"escaped \\" double quotes"
-        $string5 = "this string contains \\'escaped \\' single quotes"
-        $string6 = "this string contains \r line return"
-        $string7 = "this string contains \\\\ an escaped backslash"
-        }}
+      let(:code) do
+        <<-END
+          $string1 = "this string contins \n newline"
+          $string2 = "this string contains \ttab"
+          $string3 = "this string contains \${escaped} var"
+          $string4 = "this string contains \\"escaped \\" double quotes"
+          $string5 = "this string contains \\'escaped \\' single quotes"
+          $string6 = "this string contains \r line return"
+          $string7 = "this string contains \\\\ an escaped backslash"
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -108,7 +112,7 @@ describe 'double_quoted_strings' do
     end
 
     context 'double quoted string with random escape should be rejected' do
-      let(:code) {%{ $ztring = "this string contains \l random esape" } }
+      let(:code) { %( $ztring = "this string contains \l random esape" ) }
 
       it 'should only detect a single problem' do
         expect(problems).to have(1).problem
@@ -128,7 +132,7 @@ describe 'double_quoted_strings' do
     end
 
     context 'double quoted string containing single quoted string' do
-      let(:code) { %[notify { "'foo'": }] }
+      let(:code) { %(notify { "'foo'": }) }
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -158,7 +162,7 @@ describe 'double_quoted_strings' do
     end
 
     context 'double quoted string containing a lone dollar' do
-      let(:code) {"\"sed -i 's/^;*[[:space:]]*${name}[[:space:]]*=.*$/${name} = ${value}/g' file\"" }
+      let(:code) { "\"sed -i 's/^;*[[:space:]]*${name}[[:space:]]*=.*$/${name} = ${value}/g' file\"" }
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems

data/spec/puppet-lint/plugins/check_strings/only_variable_string_spec.rb

@@ -41,12 +41,14 @@ describe 'only_variable_string' do
     end
 
     context 'string containing only a variable as a hash key' do
-      let(:code) { "
-        $bar = 'key'
-        $foo = {
-          \"$bar\" => 1,
-        }"
-      }
+      let(:code) do
+        <<-END
+          $bar = 'key'
+          $foo = {
+            \"$bar\" => 1,
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to be_empty
@@ -75,7 +77,7 @@ describe 'only_variable_string' do
       end
 
       it 'should unquote the variable' do
-        expect(manifest).to eq("$foo")
+        expect(manifest).to eq('$foo')
       end
     end
 
@@ -91,7 +93,7 @@ describe 'only_variable_string' do
       end
 
       it 'should unquoted the variable' do
-        expect(manifest).to eq("$foo[0]")
+        expect(manifest).to eq('$foo[0]')
       end
     end
 
@@ -107,7 +109,7 @@ describe 'only_variable_string' do
       end
 
       it 'should unquote the variable' do
-        expect(manifest).to eq("$foo[0][aoeuaoeu][bar][999]")
+        expect(manifest).to eq('$foo[0][aoeuaoeu][bar][999]')
       end
     end
   end

data/spec/puppet-lint/plugins/check_strings/puppet_url_without_modules_spec.rb

@@ -50,13 +50,12 @@ describe 'puppet_url_without_modules' do
       end
     end
   end
-  
+
   context 'double string wrapped puppet:// urls' do
     let(:code) { File.read('spec/fixtures/test/manifests/url_interpolation.pp') }
 
     it 'should detect several problems' do
       expect(problems).to have(4).problem
     end
-
   end
 end

data/spec/puppet-lint/plugins/check_strings/single_quote_string_with_variables_spec.rb

@@ -16,25 +16,29 @@ describe 'single_quote_string_with_variables' do
   end
 
   context 'single quoted inline template with dollar signs has no problems' do
-    let (:code) {"
-      $list = ['one', 'two', 'three']
-      file { '/tmp/text.txt':
-        ensure  => file,
-        content => inline_template('<% $list.each |$item| { %><%= \"${item}\n\" %><% } %>'),
-      }
-    "}
+    let(:code) do
+      <<-END
+        $list = ['one', 'two', 'three']
+        file { '/tmp/text.txt':
+          ensure  => file,
+          content => inline_template('<% $list.each |$item| { %><%= "${item}\n" %><% } %>'),
+        }
+      END
+    end
 
     it { expect(problems).to have(0).problem }
   end
 
   context 'single quoted inline epp with dollar signs has no problems' do
-    let (:code) {"
-      $list = ['one', 'two', 'three']
-      file { '/tmp/text.txt':
-        ensure  => file,
-        content => inline_template('<% @list.each do |item| %><%= @item %>\n<% end %>'),
-      }
-    "}
+    let(:code) do
+      <<-END
+        $list = ['one', 'two', 'three']
+        file { '/tmp/text.txt':
+          ensure  => file,
+          content => inline_template('<% @list.each do |item| %><%= @item %>\n<% end %>'),
+        }
+      END
+    end
 
     it { expect(problems).to have(0).problem }
   end

data/spec/puppet-lint/plugins/check_variables/variable_contains_dash_spec.rb

@@ -28,7 +28,7 @@ describe 'variable_contains_dash' do
   end
 
   context 'variable with an array reference containing a dash' do
-    let(:code) { "$foo[bar-baz]" }
+    let(:code) { '$foo[bar-baz]' }
 
     it 'should not detect any problems' do
       expect(problems).to be_empty

data/spec/puppet-lint/plugins/check_variables/variable_is_lowercase_spec.rb

@@ -9,7 +9,7 @@ describe 'variable_is_lowercase' do
     it 'should only detect a single problem' do
       expect(problems).to have(1).problem
     end
-  
+
     it 'should create a warning' do
       expect(problems).to contain_warning(msg).on_line(1).in_column(1)
     end

data/spec/puppet-lint/plugins/check_whitespace/140chars_spec.rb

@@ -1,15 +1,18 @@
 # encoding: utf-8
+
 require 'spec_helper'
 
 describe '140chars' do
   let(:msg) { 'line has more than 140 characters' }
 
   context 'file resource with a source line > 140c' do
-    let(:code) { "
-      file {
-        source  => 'puppet:///modules/certificates/etc/ssl/private/wildcard.example.com.crt',
-      }"
-    }
+    let(:code) do
+      <<-END
+        file {
+          source  => 'puppet:///modules/certificates/etc/ssl/private/wildcard.example.com.crt',
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -17,11 +20,13 @@ describe '140chars' do
   end
 
   context 'file resource with a template line > 140c' do
-    let(:code) { "
-      file {
-        content => template('mymodule/this/is/a/truely/absurdly/long/path/that/should/make/you/feel/bad'),
-      }"
-    }
+    let(:code) do
+      <<-END
+        file {
+          content => template('mymodule/this/is/a/truely/absurdly/long/path/that/should/make/you/feel/bad'),
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -29,11 +34,13 @@ describe '140chars' do
   end
 
   context 'length of lines with UTF-8 characters' do
-    let(:code) { "
-      # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
-      # ┃          Configuration           ┃
-      # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
-    }
+    let(:code) do
+      <<-END
+        # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+        # ┃          Configuration           ┃
+        # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems

data/spec/puppet-lint/plugins/check_whitespace/2sp_soft_tabs_spec.rb

@@ -4,18 +4,20 @@ describe '2sp_soft_tabs' do
   let(:msg) { 'two-space soft tabs not used' }
 
   context 'when a line is indented by 3 spaces' do
-    let(:code) { "
-      file { 'foo':
-         foo => bar,
-      }"
-    }
+    let(:code) do
+      <<-END
+        file { 'foo':
+           foo => bar,
+        }
+      END
+    end
 
     it 'should only detect a single problem' do
       expect(problems).to have(1).problem
     end
 
     it 'should create an error' do
-      expect(problems).to contain_error(msg).on_line(3).in_column(1)
+      expect(problems).to contain_error(msg).on_line(2).in_column(1)
     end
   end
 end

data/spec/puppet-lint/plugins/check_whitespace/80chars_spec.rb

@@ -1,19 +1,22 @@
 # encoding: utf-8
+
 require 'spec_helper'
 
 describe '80chars' do
   before do
-    PuppetLint.configuration.send("enable_80chars")
+    PuppetLint.configuration.send('enable_80chars')
   end
 
   let(:msg) { 'line has more than 80 characters' }
 
   context 'file resource with a source line > 80c' do
-    let(:code) { "
-      file {
-        source  => 'puppet:///modules/certificates/etc/ssl/private/wildcard.example.com.crt',
-      }"
-    }
+    let(:code) do
+      <<-END
+        file {
+          source  => 'puppet:///modules/certificates/etc/ssl/private/wildcard.example.com.crt',
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -21,11 +24,13 @@ describe '80chars' do
   end
 
   context 'file resource with a template line > 80c' do
-    let(:code) { "
-      file {
-        content => template('mymodule/this/is/a/truely/absurdly/long/path/that/should/make/you/feel/bad'),
-      }"
-    }
+    let(:code) do
+      <<-END
+        file {
+          content => template('mymodule/this/is/a/truely/absurdly/long/path/that/should/make/you/feel/bad'),
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -33,11 +38,13 @@ describe '80chars' do
   end
 
   context 'length of lines with UTF-8 characters' do
-    let(:code) { "
-      # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
-      # ┃          Configuration           ┃
-      # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
-    }
+    let(:code) do
+      <<-END
+        # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+        # ┃          Configuration           ┃
+        # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -55,17 +62,4 @@ describe '80chars' do
       expect(problems).to contain_warning(msg).on_line(1).in_column(80)
     end
   end
-
-# TODO: figure out why rspec keeps enabling this check!
-#
-#   context '81 character line with disabled check' do
-#     let(:code) { 'a' * 81 }
-#
-#     PuppetLint.configuration.send("disable_80chars")
-#
-#     it 'should not detect any problems' do
-#       expect(problems).to have(0).problem
-#     end
-#   end
-
 end

data/spec/puppet-lint/plugins/check_whitespace/arrow_alignment_spec.rb

@@ -5,16 +5,18 @@ describe 'arrow_alignment' do
 
   context 'with fix disabled' do
     context 'selectors inside a resource' do
-      let(:code) { "
-        file { 'foo':
-          ensure  => $ensure,
-          require => $ensure ? {
-            present => Class['tomcat::install'],
-            absent  => undef;
-          },
-          foo     => bar,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure  => $ensure,
+            require => $ensure ? {
+              present => Class['tomcat::install'],
+              absent  => undef;
+            },
+            foo     => bar,
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -22,15 +24,17 @@ describe 'arrow_alignment' do
     end
 
     context 'selectors in the middle of a resource' do
-      let(:code) { "
-        file { 'foo':
-          ensure => $ensure ? {
-            present => directory,
-            absent  => undef,
-          },
-          owner  => 'tomcat6',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => $ensure ? {
+              present => directory,
+              absent  => undef,
+            },
+            owner  => 'tomcat6',
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -38,14 +42,17 @@ describe 'arrow_alignment' do
     end
 
     context 'selector inside a resource' do
-      let(:code) { "
-      ensure => $ensure ? {
-        present => directory,
-        absent  => undef,
-      },
-      owner  => 'foo4',
-      group  => 'foo4',
-      mode   => '0755'," }
+      let(:code) do
+        <<-END
+          ensure => $ensure ? {
+            present => directory,
+            absent  => undef,
+          },
+          owner  => 'foo4',
+          group  => 'foo4',
+          mode   => '0755',
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -53,17 +60,20 @@ describe 'arrow_alignment' do
     end
 
     context 'selector inside a hash inside a resource' do
-      let(:code) { "
-      server => {
-        ensure => ensure => $ensure ? {
-          present => directory,
-          absent  => undef,
-        },
-        ip     => '192.168.1.1'
-      },
-      owner  => 'foo4',
-      group  => 'foo4',
-      mode   => '0755'," }
+      let(:code) do
+        <<-END
+          server => {
+            ensure => ensure => $ensure ? {
+              present => directory,
+              absent  => undef,
+            },
+            ip     => '192.168.1.1'
+          },
+          owner  => 'foo4',
+          group  => 'foo4',
+          mode   => '0755',
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -71,32 +81,34 @@ describe 'arrow_alignment' do
     end
 
     context 'nested hashes with correct indentation' do
-      let(:code) { "
-        class { 'lvs::base':
-          virtualeservers => {
-            '192.168.2.13' => {
-              vport        => '11025',
-              service      => 'smtp',
-              scheduler    => 'wlc',
-              protocol     => 'tcp',
-              checktype    => 'external',
-              checkcommand => '/path/to/checkscript',
-              real_servers => {
-                'server01' => {
-                  real_server => '192.168.2.14',
-                  real_port   => '25',
-                  forwarding  => 'masq',
-                },
-                'server02' => {
-                  real_server => '192.168.2.15',
-                  real_port   => '25',
-                  forwarding  => 'masq',
+      let(:code) do
+        <<-END
+          class { 'lvs::base':
+            virtualeservers => {
+              '192.168.2.13' => {
+                vport        => '11025',
+                service      => 'smtp',
+                scheduler    => 'wlc',
+                protocol     => 'tcp',
+                checktype    => 'external',
+                checkcommand => '/path/to/checkscript',
+                real_servers => {
+                  'server01' => {
+                    real_server => '192.168.2.14',
+                    real_port   => '25',
+                    forwarding  => 'masq',
+                  },
+                  'server02' => {
+                    real_server => '192.168.2.15',
+                    real_port   => '25',
+                    forwarding  => 'masq',
+                  }
                 }
               }
             }
           }
-        }"
-      }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -104,128 +116,141 @@ describe 'arrow_alignment' do
     end
 
     context 'single resource with a misaligned =>' do
-      let(:code) { "
-        file { '/tmp/foo':
-          foo => 1,
-          bar => 2,
-          gronk => 3,
-          baz  => 4,
-          meh => 5,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { '/tmp/foo':
+            foo => 1,
+            bar => 2,
+            gronk => 3,
+            baz  => 4,
+            meh => 5,
+          }
+        END
+      end
 
       it 'should detect four problems' do
         expect(problems).to have(4).problems
       end
 
       it 'should create four warnings' do
-        expect(problems).to contain_warning(sprintf(msg,17,15)).on_line(3).in_column(15)
-        expect(problems).to contain_warning(sprintf(msg,17,15)).on_line(4).in_column(15)
-        expect(problems).to contain_warning(sprintf(msg,17,16)).on_line(6).in_column(16)
-        expect(problems).to contain_warning(sprintf(msg,17,15)).on_line(7).in_column(15)
+        expect(problems).to contain_warning(format(msg, 19, 17)).on_line(2).in_column(17)
+        expect(problems).to contain_warning(format(msg, 19, 17)).on_line(3).in_column(17)
+        expect(problems).to contain_warning(format(msg, 19, 18)).on_line(5).in_column(18)
+        expect(problems).to contain_warning(format(msg, 19, 17)).on_line(6).in_column(17)
       end
     end
 
     context 'single resource with a misaligned => and semicolon at the end' do
-      let(:code) { "
-        file { '/tmp/bar':
-          foo => 1,
-          bar => 2,
-          gronk => 3,
-          baz  => 4,
-          meh => 5;
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { '/tmp/bar':
+            foo => 1,
+            bar => 2,
+            gronk => 3,
+            baz  => 4,
+            meh => 5;
+          }
+        END
+      end
 
       it 'should detect four problems' do
         expect(problems).to have(4).problems
       end
 
       it 'should create four warnings' do
-        expect(problems).to contain_warning(sprintf(msg,17,15)).on_line(3).in_column(15)
-        expect(problems).to contain_warning(sprintf(msg,17,15)).on_line(4).in_column(15)
-        expect(problems).to contain_warning(sprintf(msg,17,16)).on_line(6).in_column(16)
-        expect(problems).to contain_warning(sprintf(msg,17,15)).on_line(7).in_column(15)
+        expect(problems).to contain_warning(format(msg, 19, 17)).on_line(2).in_column(17)
+        expect(problems).to contain_warning(format(msg, 19, 17)).on_line(3).in_column(17)
+        expect(problems).to contain_warning(format(msg, 19, 18)).on_line(5).in_column(18)
+        expect(problems).to contain_warning(format(msg, 19, 17)).on_line(6).in_column(17)
       end
     end
+
     context 'complex resource with a misaligned =>' do
-      let(:code) { "
-        file { '/tmp/foo':
-          foo => 1,
-          bar  => $baz ? {
-            gronk => 2,
-            meh => 3,
-          },
-          meep => 4,
-          bah => 5,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { '/tmp/foo':
+            foo => 1,
+            bar  => $baz ? {
+              gronk => 2,
+              meh => 3,
+            },
+            meep => 4,
+            bah => 5,
+          }
+        END
+      end
 
       it 'should detect three problems' do
         expect(problems).to have(3).problems
       end
 
       it 'should create three warnings' do
-        expect(problems).to contain_warning(sprintf(msg,16,15)).on_line(3).in_column(15)
-        expect(problems).to contain_warning(sprintf(msg,19,17)).on_line(6).in_column(17)
-        expect(problems).to contain_warning(sprintf(msg,16,15)).on_line(9).in_column(15)
+        expect(problems).to contain_warning(format(msg, 18, 17)).on_line(2).in_column(17)
+        expect(problems).to contain_warning(format(msg, 21, 19)).on_line(5).in_column(19)
+        expect(problems).to contain_warning(format(msg, 18, 17)).on_line(8).in_column(17)
       end
     end
 
     context 'multi-resource with a misaligned =>' do
-      let(:code) { "
-        file {
-          '/tmp/foo': ;
-          '/tmp/bar':
-            foo => 'bar';
-          '/tmp/baz':
-            gronk => 'bah',
-            meh => 'no'
-        }"
-      }
+      let(:code) do
+        <<-END
+          file {
+            '/tmp/foo': ;
+            '/tmp/bar':
+              foo => 'bar';
+            '/tmp/baz':
+              gronk => 'bah',
+              meh => 'no'
+          }
+        END
+      end
 
       it 'should only detect a single problem' do
         expect(problems).to have(1).problem
       end
 
       it 'should create a warning' do
-        expect(problems).to contain_warning(sprintf(msg,19,17)).on_line(8).in_column(17)
+        expect(problems).to contain_warning(format(msg, 21, 19)).on_line(7).in_column(19)
       end
     end
 
     context 'multi-resource with a misaligned => and semicolons' do
-      let(:code) { "
-        file {
-          '/tmp/foo':
-            ensure => 'directory',
-            owner => 'root',
-            mode => '0755';
-          '/tmp/bar':
-            ensure => 'directory';
-          '/tmp/baz':
-            ensure => 'directory',
-            owner => 'root',
-            mode => '0755';
-        }"
-      }
+      let(:code) do
+        <<-END
+          file {
+            '/tmp/foo':
+              ensure => 'directory',
+              owner => 'root',
+              mode => '0755';
+            '/tmp/bar':
+              ensure => 'directory';
+            '/tmp/baz':
+              ensure => 'directory',
+              owner => 'root',
+              mode => '0755';
+          }
+        END
+      end
 
       it 'should only detect a single problem' do
         expect(problems).to have(4).problem
       end
 
       it 'should create a warning' do
-        expect(problems).to contain_warning(sprintf(msg,20,19)).on_line(5).in_column(19)
-        expect(problems).to contain_warning(sprintf(msg,20,18)).on_line(6).in_column(18)
-        expect(problems).to contain_warning(sprintf(msg,20,19)).on_line(11).in_column(19)
-        expect(problems).to contain_warning(sprintf(msg,20,18)).on_line(12).in_column(18)
+        expect(problems).to contain_warning(format(msg, 22, 21)).on_line(4).in_column(21)
+        expect(problems).to contain_warning(format(msg, 22, 20)).on_line(5).in_column(20)
+        expect(problems).to contain_warning(format(msg, 22, 21)).on_line(10).in_column(21)
+        expect(problems).to contain_warning(format(msg, 22, 20)).on_line(11).in_column(20)
       end
     end
 
     context 'multiple single line resources' do
-      let(:code) { "
-        file { 'foo': ensure => file }
-        package { 'bar': ensure => present }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo': ensure => file }
+          package { 'bar': ensure => present }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -233,12 +258,14 @@ describe 'arrow_alignment' do
     end
 
     context 'resource with unaligned => in commented line' do
-      let(:code) { "
-        file { 'foo':
-          ensure => directory,
-          # purge => true,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => directory,
+            # purge => true,
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -246,11 +273,13 @@ describe 'arrow_alignment' do
     end
 
     context 'single line resource spread out on multiple lines' do
-      let(:code) {"
-        file {
-          'foo': ensure => present,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file {
+            'foo': ensure => present,
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -258,11 +287,13 @@ describe 'arrow_alignment' do
     end
 
     context 'multiline resource with a single line of params' do
-      let(:code) { "
-        mymodule::do_thing { 'some thing':
-          whatever => { foo => 'bar', one => 'two' },
-        }"
-      }
+      let(:code) do
+        <<-END
+          mymodule::do_thing { 'some thing':
+            whatever => { foo => 'bar', one => 'two' },
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -270,31 +301,35 @@ describe 'arrow_alignment' do
     end
 
     context 'resource with aligned => too far out' do
-      let(:code) { "
-        file { '/tmp/foo':
-          ensure  => file,
-          mode    => '0444',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { '/tmp/foo':
+            ensure  => file,
+            mode    => '0444',
+          }
+        END
+      end
 
       it 'should detect 2 problems' do
         expect(problems).to have(2).problems
       end
 
       it 'should create 2 warnings' do
-        expect(problems).to contain_warning(sprintf(msg,18,19)).on_line(3).in_column(19)
-        expect(problems).to contain_warning(sprintf(msg,18,19)).on_line(4).in_column(19)
+        expect(problems).to contain_warning(format(msg, 20, 21)).on_line(2).in_column(21)
+        expect(problems).to contain_warning(format(msg, 20, 21)).on_line(3).in_column(21)
       end
     end
 
     context 'resource with multiple params where one is an empty hash' do
-      let(:code) { "
-        foo { 'foo':
-          a => true,
-          b => {
+      let(:code) do
+        <<-END
+          foo { 'foo':
+            a => true,
+            b => {
+            }
           }
-        }
-      "}
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -302,30 +337,34 @@ describe 'arrow_alignment' do
     end
 
     context 'multiline resource with multiple params on a line' do
-      let(:code) { "
-        user { 'test':
-          a => 'foo', bb => 'bar',
-          ccc => 'baz',
-        }
-      " }
+      let(:code) do
+        <<-END
+          user { 'test':
+            a => 'foo', bb => 'bar',
+            ccc => 'baz',
+          }
+        END
+      end
 
       it 'should detect 2 problems' do
         expect(problems).to have(2).problems
       end
 
       it 'should create 2 warnings' do
-        expect(problems).to contain_warning(sprintf(msg,15,13)).on_line(3).in_column(13)
-        expect(problems).to contain_warning(sprintf(msg,15,26)).on_line(3).in_column(26)
+        expect(problems).to contain_warning(format(msg, 17, 15)).on_line(2).in_column(15)
+        expect(problems).to contain_warning(format(msg, 17, 28)).on_line(2).in_column(28)
       end
     end
 
     context 'resource param containing a single-element same-line hash' do
-      let(:code) { "
-        foo { 'foo':
-          a => true,
-          b => { 'a' => 'b' }
-        }
-      "}
+      let(:code) do
+        <<-END
+          foo { 'foo':
+            a => true,
+            b => { 'a' => 'b' }
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -333,14 +372,16 @@ describe 'arrow_alignment' do
     end
 
     context 'multiline hash with opening brace on same line as first pair' do
-      let(:code) { "
-        foo { 'foo':
-          bar => [
-            { aa => bb,
-              c  => d},
-          ],
-        }
-      " }
+      let(:code) do
+        <<-END
+          foo { 'foo':
+            bar => [
+              { aa => bb,
+                c  => d},
+            ],
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -348,34 +389,38 @@ describe 'arrow_alignment' do
     end
 
     context 'unaligned multiline hash with opening brace on the same line as the first pair' do
-      let(:code) { "
-        foo { 'foo':
-          bar => [
-            { aa => bb,
-              c => d},
-          ],
-        }
-      " }
+      let(:code) do
+        <<-END
+          foo { 'foo':
+            bar => [
+              { aa => bb,
+                c => d},
+            ],
+          }
+        END
+      end
 
       it 'should detect one problem' do
         expect(problems).to have(1).problem
       end
 
       it 'should create one warning' do
-        expect(problems).to contain_warning(sprintf(msg,18,17)).on_line(5).in_column(17)
+        expect(problems).to contain_warning(format(msg, 20, 19)).on_line(4).in_column(19)
       end
     end
 
     context 'hash with strings containing variables as keys properly aligned' do
-      let(:code) { '
-        foo { foo:
-          param => {
-            a         => 1
-            "${aoeu}" => 2,
-            b         => 3,
-          },
-        }
-      ' }
+      let(:code) do
+        <<-END
+          foo { foo:
+            param => {
+              a         => 1
+              "${aoeu}" => 2,
+              b         => 3,
+            },
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -383,42 +428,46 @@ describe 'arrow_alignment' do
     end
 
     context 'hash with strings containing variables as keys incorrectly aligned' do
-      let(:code) { '
-        foo { foo:
-          param => {
-            a => 1
-            "${aoeu}" => 2,
-            b     => 3,
-          },
-        }
-      ' }
+      let(:code) do
+        <<-END
+          foo { foo:
+            param => {
+              a => 1
+              "${aoeu}" => 2,
+              b     => 3,
+            },
+          }
+        END
+      end
 
       it 'should detect 2 problems' do
         expect(problems).to have(2).problems
       end
 
       it 'should create 2 warnings' do
-        expect(problems).to contain_warning(sprintf(msg,23,15)).on_line(4).in_column(15)
-        expect(problems).to contain_warning(sprintf(msg,23,19)).on_line(6).in_column(19)
+        expect(problems).to contain_warning(format(msg, 25, 17)).on_line(3).in_column(17)
+        expect(problems).to contain_warning(format(msg, 25, 21)).on_line(5).in_column(21)
       end
     end
 
     context 'complex data structure with different indentation levels at the same depth' do
-      let(:code) { "
-        class { 'some_class':
-          config_hash => {
-            'a_hash'   => {
-              'foo' => 'bar',
-            },
-            'an_array' => [
-              {
-                foo => 'bar',
-                bar => 'baz',
+      let(:code) do
+        <<-END
+          class { 'some_class':
+            config_hash => {
+              'a_hash'   => {
+                'foo' => 'bar',
               },
-            ],
-          },
-        }
-      " }
+              'an_array' => [
+                {
+                  foo => 'bar',
+                  bar => 'baz',
+                },
+              ],
+            },
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -426,16 +475,18 @@ describe 'arrow_alignment' do
     end
 
     context 'where the top level of the block has no parameters' do
-      let(:code) { "
-        case $::osfamily {
-          'RedHat': {
-            $datadir = $::operatingsystem ? {
-              'Amazon' => pick($datadir, 'value'),
-              default  => pick($datadir, 'value'),
+      let(:code) do
+        <<-END
+          case $::osfamily {
+            'RedHat': {
+              $datadir = $::operatingsystem ? {
+                'Amazon' => pick($datadir, 'value'),
+                default  => pick($datadir, 'value'),
+              }
             }
           }
-        }
-      " }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -453,34 +504,39 @@ describe 'arrow_alignment' do
     end
 
     context 'single resource with a misaligned =>' do
-      let(:code) { "
-        file { '/tmp/foo':
-          foo => 1,
-          bar => 2,
-          gronk => 3,
-          baz  => 4,
-          meh => 5,
-        }"
-      }
-      let(:fixed) { "
-        file { '/tmp/foo':
-          foo   => 1,
-          bar   => 2,
-          gronk => 3,
-          baz   => 4,
-          meh   => 5,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { '/tmp/foo':
+            foo => 1,
+            bar => 2,
+            gronk => 3,
+            baz  => 4,
+            meh => 5,
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          file { '/tmp/foo':
+            foo   => 1,
+            bar   => 2,
+            gronk => 3,
+            baz   => 4,
+            meh   => 5,
+          }
+        END
+      end
 
       it 'should detect four problems' do
         expect(problems).to have(4).problems
       end
 
       it 'should fix the manifest' do
-        expect(problems).to contain_fixed(sprintf(msg,17,15)).on_line(3).in_column(15)
-        expect(problems).to contain_fixed(sprintf(msg,17,15)).on_line(4).in_column(15)
-        expect(problems).to contain_fixed(sprintf(msg,17,16)).on_line(6).in_column(16)
-        expect(problems).to contain_fixed(sprintf(msg,17,15)).on_line(7).in_column(15)
+        expect(problems).to contain_fixed(format(msg, 19, 17)).on_line(2).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 19, 17)).on_line(3).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 19, 18)).on_line(5).in_column(18)
+        expect(problems).to contain_fixed(format(msg, 19, 17)).on_line(6).in_column(17)
       end
 
       it 'should align the arrows' do
@@ -489,37 +545,42 @@ describe 'arrow_alignment' do
     end
 
     context 'complex resource with a misaligned =>' do
-      let(:code) { "
-        file { '/tmp/foo':
-          foo => 1,
-          bar  => $baz ? {
-            gronk => 2,
-            meh => 3,
-          },
-          meep => 4,
-          bah => 5,
-        }"
-      }
-      let(:fixed) { "
-        file { '/tmp/foo':
-          foo  => 1,
-          bar  => $baz ? {
-            gronk => 2,
-            meh   => 3,
-          },
-          meep => 4,
-          bah  => 5,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { '/tmp/foo':
+            foo => 1,
+            bar  => $baz ? {
+              gronk => 2,
+              meh => 3,
+            },
+            meep => 4,
+            bah => 5,
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          file { '/tmp/foo':
+            foo  => 1,
+            bar  => $baz ? {
+              gronk => 2,
+              meh   => 3,
+            },
+            meep => 4,
+            bah  => 5,
+          }
+        END
+      end
 
       it 'should detect three problems' do
         expect(problems).to have(3).problems
       end
 
       it 'should fix the manifest' do
-        expect(problems).to contain_fixed(sprintf(msg,16,15)).on_line(3).in_column(15)
-        expect(problems).to contain_fixed(sprintf(msg,19,17)).on_line(6).in_column(17)
-        expect(problems).to contain_fixed(sprintf(msg,16,15)).on_line(9).in_column(15)
+        expect(problems).to contain_fixed(format(msg, 18, 17)).on_line(2).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 21, 19)).on_line(5).in_column(19)
+        expect(problems).to contain_fixed(format(msg, 18, 17)).on_line(8).in_column(17)
       end
 
       it 'should align the arrows' do
@@ -528,33 +589,38 @@ describe 'arrow_alignment' do
     end
 
     context 'multi-resource with a misaligned =>' do
-      let(:code) { "
-        file {
-          '/tmp/foo': ;
-          '/tmp/bar':
-            foo => 'bar';
-          '/tmp/baz':
-            gronk => 'bah',
-            meh => 'no'
-        }"
-      }
-      let(:fixed) { "
-        file {
-          '/tmp/foo': ;
-          '/tmp/bar':
-            foo => 'bar';
-          '/tmp/baz':
-            gronk => 'bah',
-            meh   => 'no'
-        }"
-      }
+      let(:code) do
+        <<-END
+          file {
+            '/tmp/foo': ;
+            '/tmp/bar':
+              foo => 'bar';
+            '/tmp/baz':
+              gronk => 'bah',
+              meh => 'no'
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          file {
+            '/tmp/foo': ;
+            '/tmp/bar':
+              foo => 'bar';
+            '/tmp/baz':
+              gronk => 'bah',
+              meh   => 'no'
+          }
+        END
+      end
 
       it 'should only detect a single problem' do
         expect(problems).to have(1).problem
       end
 
       it 'should fix the manifest' do
-        expect(problems).to contain_fixed(sprintf(msg,19,17)).on_line(8).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 21, 19)).on_line(7).in_column(19)
       end
 
       it 'should align the arrows' do
@@ -563,27 +629,31 @@ describe 'arrow_alignment' do
     end
 
     context 'resource with aligned => too far out' do
-      let(:code) { "
-        file { '/tmp/foo':
-          ensure  => file,
-          mode    => '0444',
-        }"
-      }
-
-      let(:fixed) { "
-        file { '/tmp/foo':
-          ensure => file,
-          mode   => '0444',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { '/tmp/foo':
+            ensure  => file,
+            mode    => '0444',
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          file { '/tmp/foo':
+            ensure => file,
+            mode   => '0444',
+          }
+        END
+      end
 
       it 'should detect 2 problems' do
         expect(problems).to have(2).problems
       end
 
       it 'should create 2 warnings' do
-        expect(problems).to contain_fixed(sprintf(msg,18,19)).on_line(3).in_column(19)
-        expect(problems).to contain_fixed(sprintf(msg,18,19)).on_line(4).in_column(19)
+        expect(problems).to contain_fixed(format(msg, 20, 21)).on_line(2).in_column(21)
+        expect(problems).to contain_fixed(format(msg, 20, 21)).on_line(3).in_column(21)
       end
 
       it 'should realign the arrows with the minimum whitespace' do
@@ -592,26 +662,30 @@ describe 'arrow_alignment' do
     end
 
     context 'resource with unaligned => and no whitespace between param and =>' do
-      let(:code) { "
-        user { 'test':
-          param1 => 'foo',
-          param2=> 'bar',
-        }
-      " }
-
-      let(:fixed) { "
-        user { 'test':
-          param1 => 'foo',
-          param2 => 'bar',
-        }
-      " }
+      let(:code) do
+        <<-END
+          user { 'test':
+            param1 => 'foo',
+            param2=> 'bar',
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          user { 'test':
+            param1 => 'foo',
+            param2 => 'bar',
+          }
+        END
+      end
 
       it 'should detect 1 problem' do
         expect(problems).to have(1).problem
       end
 
       it 'should fix the problem' do
-        expect(problems).to contain_fixed(sprintf(msg,18,17)).on_line(4).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 20, 19)).on_line(3).in_column(19)
       end
 
       it 'should add whitespace between the param and the arrow' do
@@ -620,28 +694,32 @@ describe 'arrow_alignment' do
     end
 
     context 'multiline resource with multiple params on a line' do
-      let(:code) { "
-        user { 'test':
-          a => 'foo', bb => 'bar',
-          ccc => 'baz',
-        }
-      " }
-
-      let(:fixed) { "
-        user { 'test':
-          a   => 'foo',
-          bb  => 'bar',
-          ccc => 'baz',
-        }
-      " }
+      let(:code) do
+        <<-END
+          user { 'test':
+            a => 'foo', bb => 'bar',
+            ccc => 'baz',
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          user { 'test':
+            a   => 'foo',
+            bb  => 'bar',
+            ccc => 'baz',
+          }
+        END
+      end
 
       it 'should detect 2 problems' do
         expect(problems).to have(2).problems
       end
 
       it 'should fix 2 problems' do
-        expect(problems).to contain_fixed(sprintf(msg,15,13)).on_line(3).in_column(13)
-        expect(problems).to contain_fixed(sprintf(msg,15,26)).on_line(3).in_column(26)
+        expect(problems).to contain_fixed(format(msg, 17, 15)).on_line(2).in_column(15)
+        expect(problems).to contain_fixed(format(msg, 17, 28)).on_line(2).in_column(28)
       end
 
       it 'should move the extra param onto its own line and realign' do
@@ -650,64 +728,72 @@ describe 'arrow_alignment' do
     end
 
     context 'multiline resource with multiple params on a line, extra one longer' do
-      let(:code) { "
-        user { 'test':
-          a => 'foo', bbccc => 'bar',
-          ccc => 'baz',
-        }
-      " }
-
-      let(:fixed) { "
-        user { 'test':
-          a     => 'foo',
-          bbccc => 'bar',
-          ccc   => 'baz',
-        }
-      " }
+      let(:code) do
+        <<-END
+          user { 'test':
+            a => 'foo', bbccc => 'bar',
+            ccc => 'baz',
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          user { 'test':
+            a     => 'foo',
+            bbccc => 'bar',
+            ccc   => 'baz',
+          }
+        END
+      end
 
       it 'should detect 2 problems' do
         expect(problems).to have(3).problems
       end
 
       it 'should fix 2 problems' do
-        expect(problems).to contain_fixed(sprintf(msg,17,13)).on_line(3).in_column(13)
-        expect(problems).to contain_fixed(sprintf(msg,17,29)).on_line(3).in_column(29)
-        expect(problems).to contain_fixed(sprintf(msg,17,15)).on_line(4).in_column(15)
+        expect(problems).to contain_fixed(format(msg, 19, 15)).on_line(2).in_column(15)
+        expect(problems).to contain_fixed(format(msg, 19, 31)).on_line(2).in_column(31)
+        expect(problems).to contain_fixed(format(msg, 19, 17)).on_line(3).in_column(17)
       end
 
       it 'should move the extra param onto its own line and realign' do
         expect(manifest).to eq(fixed)
       end
     end
-    
+
     context 'hash with strings containing variables as keys incorrectly aligned' do
-      let(:code) { '
-        foo { foo:
-          param => {
-            a => 1
-            "${aoeu}" => 2,
-            b     => 3,
-          },
-        }
-      ' }
-      let(:fixed) { '
-        foo { foo:
-          param => {
-            a         => 1
-            "${aoeu}" => 2,
-            b         => 3,
-          },
-        }
-      ' }
+      let(:code) do
+        <<-END
+          foo { foo:
+            param => {
+              a => 1
+              "${aoeu}" => 2,
+              b     => 3,
+            },
+          }
+        END
+      end
 
+      let(:fixed) do
+        <<-END
+          foo { foo:
+            param => {
+              a         => 1
+              "${aoeu}" => 2,
+              b         => 3,
+            },
+          }
+        END
+      end
 
       it 'should detect 2 problems' do
         expect(problems).to have(2).problems
       end
 
       it 'should fix 2 problems' do
-        expect(problems).to contain_fixed(sprintf(msg,23,15)).on_line(4).in_column(15)
-        expect(problems).to contain_fixed(sprintf(msg,23,19)).on_line(6).in_column(19)
+        expect(problems).to contain_fixed(format(msg, 25, 17)).on_line(3).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 25, 21)).on_line(5).in_column(21)
       end
 
       it 'should align the hash rockets' do
@@ -716,44 +802,48 @@ describe 'arrow_alignment' do
     end
 
     context 'complex data structure with different indentation levels at the same depth' do
-      let(:code) { "
-        class { 'some_class':
-          config_hash => {
-            'a_hash'   => {
-              'foo' => 'bar',
-            },
-            'an_array' => [
-              {
-                foo => 'bar',
-                bar  => 'baz',
+      let(:code) do
+        <<-END
+          class { 'some_class':
+            config_hash => {
+              'a_hash'   => {
+                'foo' => 'bar',
               },
-            ],
-          },
-        }
-      " }
-
-      let(:fixed) { "
-        class { 'some_class':
-          config_hash => {
-            'a_hash'   => {
-              'foo' => 'bar',
+              'an_array' => [
+                {
+                  foo => 'bar',
+                  bar  => 'baz',
+                },
+              ],
             },
-            'an_array' => [
-              {
-                foo => 'bar',
-                bar => 'baz',
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class { 'some_class':
+            config_hash => {
+              'a_hash'   => {
+                'foo' => 'bar',
               },
-            ],
-          },
-        }
-      " }
+              'an_array' => [
+                {
+                  foo => 'bar',
+                  bar => 'baz',
+                },
+              ],
+            },
+          }
+        END
+      end
 
       it 'should detect 1 problem' do
         expect(problems).to have(1).problems
       end
 
       it 'should fix 1 problem' do
-        expect(problems).to contain_fixed(sprintf(msg, 21, 22)).on_line(10).in_column(22)
+        expect(problems).to contain_fixed(format(msg, 23, 24)).on_line(9).in_column(24)
       end
 
       it 'should align the hash rockets' do
@@ -762,58 +852,60 @@ describe 'arrow_alignment' do
     end
 
     context 'complex data structure with multiple token keys' do
-      let(:code) { <<-END.gsub(/^ {8}/, '')
-        class example (
-          $external_ip_base,
-        ) {
-
-          bar { 'xxxxxxxxx':
-            inputs => {
-              'ny' => {
-                "${external_ip_base}.16:443 ${a} ${b} ${c}" => 'foo',
-                'veryveryverylongstring8:443'=> 'foo',
-                'simple'=> 'foo',
-                '3'=> :foo,
-                :baz=> :qux,
-                3=> 3,
+      let(:code) do
+        <<-END.gsub(%r{^ {10}}, '')
+          class example (
+            $external_ip_base,
+          ) {
+
+            bar { 'xxxxxxxxx':
+              inputs => {
+                'ny' => {
+                  "${external_ip_base}.16:443 ${a} ${b} ${c}" => 'foo',
+                  'veryveryverylongstring8:443'=> 'foo',
+                  'simple'=> 'foo',
+                  '3'=> :foo,
+                  :baz=> :qux,
+                  3=> 3,
+                },
               },
-            },
+            }
           }
-        }
         END
-      }
-
-      let(:fixed) { <<-END.gsub(/^ {8}/, '')
-        class example (
-          $external_ip_base,
-        ) {
+      end
 
-          bar { 'xxxxxxxxx':
-            inputs => {
-              'ny' => {
-                "${external_ip_base}.16:443 ${a} ${b} ${c}" => 'foo',
-                'veryveryverylongstring8:443'               => 'foo',
-                'simple'                                    => 'foo',
-                '3'                                         => :foo,
-                :baz                                        => :qux,
-                3                                           => 3,
+      let(:fixed) do
+        <<-END.gsub(%r{^ {10}}, '')
+          class example (
+            $external_ip_base,
+          ) {
+
+            bar { 'xxxxxxxxx':
+              inputs => {
+                'ny' => {
+                  "${external_ip_base}.16:443 ${a} ${b} ${c}" => 'foo',
+                  'veryveryverylongstring8:443'               => 'foo',
+                  'simple'                                    => 'foo',
+                  '3'                                         => :foo,
+                  :baz                                        => :qux,
+                  3                                           => 3,
+                },
               },
-            },
+            }
           }
-        }
         END
-      }
+      end
 
       it 'should detect 5 problems' do
         expect(problems).to have(5).problems
       end
 
       it 'should fix 5 problems' do
-        expect(problems).to contain_fixed(sprintf(msg, 53, 38)).on_line(9).in_column(38)
-        expect(problems).to contain_fixed(sprintf(msg, 53, 17)).on_line(10).in_column(17)
-        expect(problems).to contain_fixed(sprintf(msg, 53, 12)).on_line(11).in_column(12)
-        expect(problems).to contain_fixed(sprintf(msg, 53, 13)).on_line(12).in_column(13)
-        expect(problems).to contain_fixed(sprintf(msg, 53, 10)).on_line(13).in_column(10)
+        expect(problems).to contain_fixed(format(msg, 53, 38)).on_line(9).in_column(38)
+        expect(problems).to contain_fixed(format(msg, 53, 17)).on_line(10).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 53, 12)).on_line(11).in_column(12)
+        expect(problems).to contain_fixed(format(msg, 53, 13)).on_line(12).in_column(13)
+        expect(problems).to contain_fixed(format(msg, 53, 10)).on_line(13).in_column(10)
       end
 
       it 'should realign the arrows' do
@@ -822,51 +914,53 @@ describe 'arrow_alignment' do
     end
 
     context 'realignment of resource with an inline single line hash' do
-      let(:code) { <<-END.gsub(/^ {8}/, '')
-        class { 'puppetdb':
-          database                => 'embedded',
-          #database                => 'postgres',
-          #postgres_version        => '9.3',
-          java_args               => { '-Xmx' => '512m', '-Xms' => '256m' },
-          listen_address          => $::ipaddress_eth0,
-          listen_port             => 4998,
-          ssl_listen_address      => $::ipaddress_eth0,
-          ssl_listen_port         => 4999,
-          open_listen_port        => false,
-          open_ssl_listen_port    => false;
-        }
-        END
-      }
-
-      let(:fixed) { <<-END.gsub(/^ {8}/, '')
-        class { 'puppetdb':
-          database             => 'embedded',
-          #database                => 'postgres',
-          #postgres_version        => '9.3',
-          java_args            => { '-Xmx' => '512m', '-Xms' => '256m' },
-          listen_address       => $::ipaddress_eth0,
-          listen_port          => 4998,
-          ssl_listen_address   => $::ipaddress_eth0,
-          ssl_listen_port      => 4999,
-          open_listen_port     => false,
-          open_ssl_listen_port => false;
-        }
-        END
-      }
+      let(:code) do
+        <<-END.gsub(%r{^ {10}}, '')
+          class { 'puppetdb':
+            database                => 'embedded',
+            #database                => 'postgres',
+            #postgres_version        => '9.3',
+            java_args               => { '-Xmx' => '512m', '-Xms' => '256m' },
+            listen_address          => $::ipaddress_eth0,
+            listen_port             => 4998,
+            ssl_listen_address      => $::ipaddress_eth0,
+            ssl_listen_port         => 4999,
+            open_listen_port        => false,
+            open_ssl_listen_port    => false;
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END.gsub(%r{^ {10}}, '')
+          class { 'puppetdb':
+            database             => 'embedded',
+            #database                => 'postgres',
+            #postgres_version        => '9.3',
+            java_args            => { '-Xmx' => '512m', '-Xms' => '256m' },
+            listen_address       => $::ipaddress_eth0,
+            listen_port          => 4998,
+            ssl_listen_address   => $::ipaddress_eth0,
+            ssl_listen_port      => 4999,
+            open_listen_port     => false,
+            open_ssl_listen_port => false;
+          }
+        END
+      end
 
       it 'should detect 8 problems' do
         expect(problems).to have(8).problems
       end
 
       it 'should fix 8 problems' do
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(2).in_column(27)
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(5).in_column(27)
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(6).in_column(27)
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(7).in_column(27)
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(8).in_column(27)
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(9).in_column(27)
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(10).in_column(27)
-        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(11).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(2).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(5).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(6).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(7).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(8).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(9).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(10).in_column(27)
+        expect(problems).to contain_fixed(format(msg, 24, 27)).on_line(11).in_column(27)
       end
 
       it 'should realign the arrows' do