puppet-lint 2.3.0 → 2.3.1

data/spec/puppet-lint/lexer/token_spec.rb

@@ -14,5 +14,5 @@ describe PuppetLint::Lexer::Token do
   its(:value) { is_expected.to eq('foo') }
   its(:line) { is_expected.to eq(1) }
   its(:column) { is_expected.to eq(2) }
-  its(:inspect) { is_expected.to eq("<Token :NAME (foo) @1:2>") }
+  its(:inspect) { is_expected.to eq('<Token :NAME (foo) @1:2>') }
 end

data/spec/puppet-lint/lexer_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe PuppetLint::Lexer do
+describe PuppetLint::Lexer do # rubocop:disable Metrics/BlockLength
   before do
     @lexer = PuppetLint::Lexer.new
   end
@@ -18,25 +20,25 @@ describe PuppetLint::Lexer do
     end
 
     it 'should get correct line number after double quoted multi line string' do
-      token = @lexer.new_token(:STRING, "test\ntest")
+      @lexer.new_token(:STRING, "test\ntest")
       token = @lexer.new_token(:TEST, 'test')
       expect(token.line).to eq(2)
     end
 
     it 'should get correct line number after a multi line comment' do
-      token = @lexer.new_token(:MLCOMMENT, "test\ntest", :raw => "/*test\ntest*/")
+      @lexer.new_token(:MLCOMMENT, "test\ntest", :raw => "/*test\ntest*/")
       token = @lexer.new_token(:TEST, 'test')
       expect(token.line).to eq(2)
     end
 
     it 'should calculate the line number for a multi line string' do
-      token = @lexer.new_token(:SSTRING, "test\ntest")
+      @lexer.new_token(:SSTRING, "test\ntest")
       token = @lexer.new_token(:TEST, 'test')
       expect(token.line).to eq(2)
     end
 
     it 'should calculate line number for string that ends with newline' do
-      token = @lexer.new_token(:SSTRING, "test\n")
+      @lexer.new_token(:SSTRING, "test\n")
       token = @lexer.new_token(:TEST, 'test')
       expect(token.line).to eq(2)
     end
@@ -55,12 +57,20 @@ describe PuppetLint::Lexer do
     it 'should calculate the column number for a multi line string' do
       @lexer.instance_variable_set('@line_no', 4)
       @lexer.instance_variable_set('@column', 5)
-      token = @lexer.new_token(:SSTRING, "test\ntest")
+      @lexer.new_token(:SSTRING, "test\ntest")
       token = @lexer.new_token(:TEST, 'test')
       expect(token.column).to eq(6)
     end
   end
 
+  describe '#slurp_string' do
+    it 'raises a LexerError if the string is not terminated' do
+      expect {
+        @lexer.slurp_string('unterminated string')
+      }.to raise_error(PuppetLint::LexerError)
+    end
+  end
+
   context '#get_string_segment' do
     it 'should get a segment with a single terminator' do
       data = StringScanner.new('foo"bar')
@@ -86,7 +96,7 @@ describe PuppetLint::Lexer do
 
   context '#interpolate_string' do
     it 'should handle a string with no variables' do
-      @lexer.interpolate_string('foo bar baz"',1, 1)
+      @lexer.interpolate_string('foo bar baz"', 1, 1)
       token = @lexer.tokens.first
 
       expect(@lexer.tokens.length).to eq(1)
@@ -97,7 +107,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle a string with a newline' do
-      @lexer.interpolate_string(%{foo\nbar"}, 1, 1)
+      @lexer.interpolate_string(%(foo\nbar"), 1, 1)
       token = @lexer.tokens.first
 
       expect(@lexer.tokens.length).to eq(1)
@@ -129,6 +139,196 @@ describe PuppetLint::Lexer do
       expect(tokens[2].column).to eq(8)
     end
 
+    it 'should handle a string with newline characters' do
+      # rubocop:disable Layout/TrailingWhitespace
+      manifest = <<END
+  exec {
+    'do-something':
+      command     => "echo > /home/bar/.token; 
+                                kdestroy; 
+                                kinit ${pseudouser}@EXAMPLE.COM -kt ${keytab_path}; 
+                                test $(klist | egrep '^Default principal:' | sed 's/Default principal:\s//') = '${pseudouser}'@EXAMPLE.COM",
+      refreshonly => true;
+  }
+END
+      # rubocop:enable Layout/TrailingWhitespace
+      tokens = @lexer.tokenise(manifest)
+
+      expect(tokens.length).to eq(36)
+
+      expect(tokens[0].type).to eq(:WHITESPACE)
+      expect(tokens[0].value).to eq('  ')
+      expect(tokens[0].line).to eq(1)
+      expect(tokens[0].column).to eq(1)
+      expect(tokens[1].type).to eq(:NAME)
+      expect(tokens[1].value).to eq('exec')
+      expect(tokens[1].line).to eq(1)
+      expect(tokens[1].column).to eq(3)
+      expect(tokens[2].type).to eq(:WHITESPACE)
+      expect(tokens[2].value).to eq(' ')
+      expect(tokens[2].line).to eq(1)
+      expect(tokens[2].column).to eq(7)
+      expect(tokens[3].type).to eq(:LBRACE)
+      expect(tokens[3].value).to eq('{')
+      expect(tokens[3].line).to eq(1)
+      expect(tokens[3].column).to eq(8)
+      expect(tokens[4].type).to eq(:NEWLINE)
+      expect(tokens[4].value).to eq("\n")
+      expect(tokens[4].line).to eq(1)
+      expect(tokens[4].column).to eq(9)
+      expect(tokens[5].type).to eq(:INDENT)
+      expect(tokens[5].value).to eq('    ')
+      expect(tokens[5].line).to eq(2)
+      expect(tokens[5].column).to eq(1)
+      expect(tokens[6].type).to eq(:SSTRING)
+      expect(tokens[6].value).to eq('do-something')
+      expect(tokens[6].line).to eq(2)
+      expect(tokens[6].column).to eq(5)
+      expect(tokens[7].type).to eq(:COLON)
+      expect(tokens[7].value).to eq(':')
+      expect(tokens[7].line).to eq(2)
+      expect(tokens[7].column).to eq(19)
+      expect(tokens[8].type).to eq(:NEWLINE)
+      expect(tokens[8].value).to eq("\n")
+      expect(tokens[8].line).to eq(2)
+      expect(tokens[8].column).to eq(20)
+      expect(tokens[9].type).to eq(:INDENT)
+      expect(tokens[9].value).to eq('      ')
+      expect(tokens[9].line).to eq(3)
+      expect(tokens[9].column).to eq(1)
+      expect(tokens[10].type).to eq(:NAME)
+      expect(tokens[10].value).to eq('command')
+      expect(tokens[10].line).to eq(3)
+      expect(tokens[10].column).to eq(7)
+      expect(tokens[11].type).to eq(:WHITESPACE)
+      expect(tokens[11].value).to eq('     ')
+      expect(tokens[11].line).to eq(3)
+      expect(tokens[11].column).to eq(14)
+      expect(tokens[12].type).to eq(:FARROW)
+      expect(tokens[12].value).to eq('=>')
+      expect(tokens[12].line).to eq(3)
+      expect(tokens[12].column).to eq(19)
+      expect(tokens[13].type).to eq(:WHITESPACE)
+      expect(tokens[13].value).to eq(' ')
+      expect(tokens[13].line).to eq(3)
+      expect(tokens[13].column).to eq(21)
+      expect(tokens[14].type).to eq(:DQPRE)
+      expect(tokens[14].value).to eq("echo > /home/bar/.token; \n                                kdestroy; \n                                kinit ")
+      expect(tokens[14].line).to eq(3)
+      expect(tokens[14].column).to eq(22)
+      expect(tokens[15].type).to eq(:VARIABLE)
+      expect(tokens[15].value).to eq('pseudouser')
+      expect(tokens[15].line).to eq(5)
+      expect(tokens[15].column).to eq(131)
+      expect(tokens[16].type).to eq(:DQMID)
+      expect(tokens[16].value).to eq('@EXAMPLE.COM -kt ')
+      expect(tokens[16].line).to eq(5)
+      expect(tokens[16].column).to eq(143)
+      expect(tokens[17].type).to eq(:VARIABLE)
+      expect(tokens[17].value).to eq('keytab_path')
+      expect(tokens[17].line).to eq(5)
+      expect(tokens[17].column).to eq(161)
+      expect(tokens[18].type).to eq(:DQMID)
+      expect(tokens[18].value).to eq("; \n                                test ")
+      expect(tokens[18].line).to eq(5)
+      expect(tokens[18].column).to eq(174)
+      expect(tokens[19].type).to eq(:DQMID)
+      expect(tokens[19].value).to eq('$')
+      expect(tokens[19].line).to eq(6)
+      expect(tokens[19].column).to eq(213)
+      expect(tokens[20].type).to eq(:DQMID)
+      expect(tokens[20].value).to eq("(klist | egrep '^Default principal:' | sed 's/Default principal: //') = '")
+      expect(tokens[20].line).to eq(6)
+      expect(tokens[20].column).to eq(215)
+      expect(tokens[21].type).to eq(:VARIABLE)
+      expect(tokens[21].value).to eq('pseudouser')
+      expect(tokens[21].line).to eq(6)
+      expect(tokens[21].column).to eq(289)
+      expect(tokens[22].type).to eq(:DQPOST)
+      expect(tokens[22].value).to eq("'@EXAMPLE.COM")
+      expect(tokens[22].line).to eq(6)
+      expect(tokens[22].column).to eq(301)
+      expect(tokens[23].type).to eq(:COMMA)
+      expect(tokens[23].value).to eq(',')
+      expect(tokens[23].line).to eq(6)
+      expect(tokens[23].column).to eq(315)
+      expect(tokens[24].type).to eq(:NEWLINE)
+      expect(tokens[24].value).to eq("\n")
+      expect(tokens[24].line).to eq(6)
+      expect(tokens[24].column).to eq(316)
+      expect(tokens[25].type).to eq(:INDENT)
+      expect(tokens[25].value).to eq('      ')
+      expect(tokens[25].line).to eq(7)
+      expect(tokens[25].column).to eq(1)
+      expect(tokens[26].type).to eq(:NAME)
+      expect(tokens[26].value).to eq('refreshonly')
+      expect(tokens[26].line).to eq(7)
+      expect(tokens[26].column).to eq(7)
+      expect(tokens[27].type).to eq(:WHITESPACE)
+      expect(tokens[27].value).to eq(' ')
+      expect(tokens[27].line).to eq(7)
+      expect(tokens[27].column).to eq(18)
+      expect(tokens[28].type).to eq(:FARROW)
+      expect(tokens[28].value).to eq('=>')
+      expect(tokens[28].line).to eq(7)
+      expect(tokens[28].column).to eq(19)
+      expect(tokens[29].type).to eq(:WHITESPACE)
+      expect(tokens[29].value).to eq(' ')
+      expect(tokens[29].line).to eq(7)
+      expect(tokens[29].column).to eq(21)
+      expect(tokens[30].type).to eq(:TRUE)
+      expect(tokens[30].value).to eq('true')
+      expect(tokens[30].line).to eq(7)
+      expect(tokens[30].column).to eq(22)
+      expect(tokens[31].type).to eq(:SEMIC)
+      expect(tokens[31].value).to eq(';')
+      expect(tokens[31].line).to eq(7)
+      expect(tokens[31].column).to eq(26)
+      expect(tokens[32].type).to eq(:NEWLINE)
+      expect(tokens[32].value).to eq("\n")
+      expect(tokens[32].line).to eq(7)
+      expect(tokens[32].column).to eq(27)
+      expect(tokens[33].type).to eq(:INDENT)
+      expect(tokens[33].value).to eq('  ')
+      expect(tokens[33].line).to eq(8)
+      expect(tokens[33].column).to eq(1)
+      expect(tokens[34].type).to eq(:RBRACE)
+      expect(tokens[34].value).to eq('}')
+      expect(tokens[34].line).to eq(8)
+      expect(tokens[34].column).to eq(3)
+      expect(tokens[35].type).to eq(:NEWLINE)
+      expect(tokens[35].value).to eq("\n")
+      expect(tokens[35].line).to eq(8)
+      expect(tokens[35].column).to eq(4)
+    end
+
+    it 'should handle a string with a single variable and newline characters' do
+      manifest = <<-END
+    foo
+    /bin/${foo} >>
+    /bar/baz"
+      END
+      @lexer.interpolate_string(manifest, 1, 1)
+      tokens = @lexer.tokens
+
+      expect(tokens.length).to eq(3)
+
+      expect(tokens[0].type).to eq(:DQPRE)
+      expect(tokens[0].value).to eq("    foo\n    /bin/")
+      expect(tokens[0].line).to eq(1)
+      expect(tokens[0].column).to eq(1)
+
+      expect(tokens[1].type).to eq(:VARIABLE)
+      expect(tokens[1].value).to eq('foo')
+      expect(tokens[1].line).to eq(2)
+      expect(tokens[1].column).to eq(20)
+
+      expect(tokens[2].type).to eq(:DQPOST)
+      expect(tokens[2].value).to eq(" >>\n    /bar/baz")
+      expect(tokens[2].line).to eq(2)
+      expect(tokens[2].column).to eq(25)
+    end
+
     it 'should handle a string with a single variable and surrounding text' do
       @lexer.interpolate_string('foo${bar}baz"', 1, 1)
       tokens = @lexer.tokens
@@ -198,12 +398,14 @@ describe PuppetLint::Lexer do
       expect(tokens[1].value).to eq('bar')
       expect(tokens[1].line).to eq(1)
       expect(tokens[1].column).to eq(3)
-      expect(tokens[1].to_manifest).to eq("${bar}")
+      expect(tokens[1].to_manifest).to eq('bar')
 
       expect(tokens[2].type).to eq(:DQPOST)
       expect(tokens[2].value).to eq('')
       expect(tokens[2].line).to eq(1)
       expect(tokens[2].column).to eq(8)
+
+      expect(tokens.map(&:to_manifest).join('')).to eq('"${bar}"')
     end
 
     it 'should not remove the unnecessary $ from enclosed variables' do
@@ -221,12 +423,14 @@ describe PuppetLint::Lexer do
       expect(tokens[1].raw).to eq('$bar')
       expect(tokens[1].line).to eq(1)
       expect(tokens[1].column).to eq(4)
-      expect(tokens[1].to_manifest).to eq("${$bar}")
+      expect(tokens[1].to_manifest).to eq('$bar')
 
       expect(tokens[2].type).to eq(:DQPOST)
       expect(tokens[2].value).to eq('')
       expect(tokens[2].line).to eq(1)
       expect(tokens[2].column).to eq(9)
+
+      expect(tokens.map(&:to_manifest).join('')).to eq('"${$bar}"')
     end
 
     it 'should handle a variable with an array reference' do
@@ -306,7 +510,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle a string with a nested string inside it' do
-      @lexer.interpolate_string(%q{string with ${'a nested single quoted string'} inside it"}, 1, 1)
+      @lexer.interpolate_string(%q(string with ${'a nested single quoted string'} inside it"), 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(3)
@@ -328,7 +532,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle a string with nested math' do
-      @lexer.interpolate_string(%q{string with ${(3+5)/4} nested math"}, 1, 1)
+      @lexer.interpolate_string('string with ${(3+5)/4} nested math"', 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(9)
@@ -376,7 +580,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle a string with a nested array' do
-      @lexer.interpolate_string(%q{string with ${['an array ', $v2]} in it"}, 1, 1)
+      @lexer.interpolate_string(%q(string with ${['an array ', $v2]} in it"), 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(8)
@@ -420,7 +624,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle a string of $s' do
-      @lexer.interpolate_string(%q{$$$$"}, 1, 1)
+      @lexer.interpolate_string('$$$$"', 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(1)
@@ -432,7 +636,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle "$foo$bar"' do
-      @lexer.interpolate_string(%q{$foo$bar"}, 1, 1)
+      @lexer.interpolate_string('$foo$bar"', 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(5)
@@ -464,7 +668,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle "foo$bar$"' do
-      @lexer.interpolate_string(%q{foo$bar$"}, 1, 1)
+      @lexer.interpolate_string('foo$bar$"', 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(3)
@@ -486,7 +690,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle "foo$$bar"' do
-      @lexer.interpolate_string(%q{foo$$bar"}, 1, 1)
+      @lexer.interpolate_string('foo$$bar"', 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(3)
@@ -508,7 +712,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle an empty string' do
-      @lexer.interpolate_string(%q{"}, 1, 1)
+      @lexer.interpolate_string('"', 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(1)
@@ -520,7 +724,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle "$foo::::bar"' do
-      @lexer.interpolate_string(%q{$foo::::bar"}, 1, 1)
+      @lexer.interpolate_string('$foo::::bar"', 1, 1)
       tokens = @lexer.tokens
 
       expect(tokens.length).to eq(3)
@@ -565,26 +769,31 @@ describe PuppetLint::Lexer do
       expect(token.column).to eq(18)
     end
 
+    it 'should not enclose variable with a chained function call' do
+      manifest = '"This is ${a.test}"'
+      tokens = @lexer.tokenise(manifest)
+      expect(tokens.map(&:to_manifest).join('')).to eq(manifest)
+    end
   end
 
-  [
-    'case',
-    'class',
-    'default',
-    'define',
-    'import',
-    'if',
-    'elsif',
-    'else',
-    'inherits',
-    'node',
-    'and',
-    'or',
-    'undef',
-    'true',
-    'false',
-    'in',
-    'unless',
+  %w[
+    case
+    class
+    default
+    define
+    import
+    if
+    elsif
+    else
+    inherits
+    node
+    and
+    or
+    undef
+    true
+    false
+    in
+    unless
   ].each do |keyword|
     it "should handle '#{keyword}' as a keyword" do
       token = @lexer.tokenise(keyword).first
@@ -640,7 +849,7 @@ describe PuppetLint::Lexer do
     [:NEWLINE, "\n"],
     [:NEWLINE, "\r\n"],
   ].each do |name, string|
-    it "should have a token named '#{name.to_s}'" do
+    it "should have a token named '#{name}'" do
       token = @lexer.tokenise(string).first
       expect(token.type).to eq(name)
       expect(token.value).to eq(string)
@@ -675,7 +884,7 @@ describe PuppetLint::Lexer do
 
   context ':HEREDOC without interpolation' do
     it 'should parse a simple heredoc' do
-      manifest = <<-END.gsub(/^ {6}/, '')
+      manifest = <<-END.gsub(%r{^ {6}}, '')
       $str = @(myheredoc)
         SOMETHING
         ELSE
@@ -686,7 +895,7 @@ describe PuppetLint::Lexer do
 
       expect(tokens.length).to eq(8)
       expect(tokens[0].type).to eq(:VARIABLE)
-      expect(tokens[0].value).to eq("str")
+      expect(tokens[0].value).to eq('str')
       expect(tokens[0].line).to eq(1)
       expect(tokens[0].column).to eq(1)
       expect(tokens[1].type).to eq(:WHITESPACE)
@@ -720,7 +929,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should not interpolate the contents of the heredoc' do
-      manifest = <<-END.gsub(/^ {6}/, '')
+      manifest = <<-END.gsub(%r{^ {6}}, '')
       $str = @(myheredoc)
         SOMETHING
         ${else}
@@ -766,7 +975,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle multiple heredoc declarations on a single line' do
-      manifest = <<-END.gsub(/^ {6}/, '')
+      manifest = <<-END.gsub(%r{^ {6}}, '')
       $str = "${@(end1)} ${@(end2)}"
         foo
         |-end1
@@ -837,7 +1046,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should handle a heredoc that specifies a syntax' do
-      manifest = <<-END.gsub(/^ {6}/, '')
+      manifest = <<-END.gsub(%r{^ {6}}, '')
       $str = @("end":json/)
         {
           "foo": "bar"
@@ -849,7 +1058,7 @@ describe PuppetLint::Lexer do
 
       expect(tokens.length).to eq(8)
       expect(tokens[0].type).to eq(:VARIABLE)
-      expect(tokens[0].value).to eq("str")
+      expect(tokens[0].value).to eq('str')
       expect(tokens[0].line).to eq(1)
       expect(tokens[0].column).to eq(1)
       expect(tokens[1].type).to eq(:WHITESPACE)
@@ -886,7 +1095,7 @@ describe PuppetLint::Lexer do
 
   context ':HEREDOC with interpolation' do
     it 'should parse a heredoc with no interpolated values as a :HEREDOC' do
-      manifest = <<-END.gsub(/^ {6}/, '')
+      manifest = <<-END.gsub(%r{^ {6}}, '')
       $str = @("myheredoc"/)
         SOMETHING
         ELSE
@@ -896,7 +1105,7 @@ describe PuppetLint::Lexer do
       tokens = @lexer.tokenise(manifest)
 
       expect(tokens[0].type).to eq(:VARIABLE)
-      expect(tokens[0].value).to eq("str")
+      expect(tokens[0].value).to eq('str')
       expect(tokens[0].line).to eq(1)
       expect(tokens[0].column).to eq(1)
       expect(tokens[1].type).to eq(:WHITESPACE)
@@ -931,7 +1140,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should parse a heredoc with interpolated values' do
-      manifest = <<-END.gsub(/^ {6}/, '')
+      manifest = <<-END.gsub(%r{^ {6}}, '')
       $str = @("myheredoc"/)
         SOMETHING
         ${else}
@@ -942,6 +1151,7 @@ describe PuppetLint::Lexer do
       END
 
       tokens = @lexer.tokenise(manifest)
+      expect(tokens.map(&:to_manifest).join('')).to eq(manifest)
 
       expect(tokens[0].type).to eq(:VARIABLE)
       expect(tokens[0].value).to eq('str')
@@ -972,19 +1182,20 @@ describe PuppetLint::Lexer do
       expect(tokens[6].line).to eq(2)
       expect(tokens[6].column).to eq(1)
       expect(tokens[7].type).to eq(:VARIABLE)
-      expect(tokens[7].value).to eq("else")
+      expect(tokens[7].value).to eq('else')
       expect(tokens[7].line).to eq(3)
-      expect(tokens[7].column).to eq(3)
-      expect(tokens[7].to_manifest).to eq("${else}")
+      expect(tokens[7].column).to eq(5)
+      expect(tokens[7].to_manifest).to eq('else')
       expect(tokens[8].type).to eq(:HEREDOC_MID)
       expect(tokens[8].value).to eq("\n  AND :\n  ")
       expect(tokens[8].line).to eq(3)
-      expect(tokens[8].column).to eq(10)
+      expect(tokens[8].column).to eq(9)
+      expect(tokens[8].to_manifest).to eq("}\n  AND :\n  ")
       expect(tokens[9].type).to eq(:UNENC_VARIABLE)
-      expect(tokens[9].value).to eq("another")
+      expect(tokens[9].value).to eq('another')
       expect(tokens[9].line).to eq(5)
       expect(tokens[9].column).to eq(3)
-      expect(tokens[9].to_manifest).to eq("$another")
+      expect(tokens[9].to_manifest).to eq('$another')
       expect(tokens[10].type).to eq(:HEREDOC_POST)
       expect(tokens[10].value).to eq("\n  THING\n  ")
       expect(tokens[10].raw).to eq("\n  THING\n  | myheredoc")
@@ -993,7 +1204,7 @@ describe PuppetLint::Lexer do
     end
 
     it 'should not remove the unnecessary $ from enclosed variables' do
-      manifest = <<-END.gsub(/^ {6}/, '')
+      manifest = <<-END.gsub(%r{^ {6}}, '')
       $str = @("myheredoc"/)
         ${$myvar}
         |-myheredoc
@@ -1005,7 +1216,9 @@ describe PuppetLint::Lexer do
       expect(tokens[7].type).to eq(:VARIABLE)
       expect(tokens[7].value).to eq('myvar')
       expect(tokens[7].raw).to eq('$myvar')
-      expect(tokens[7].to_manifest).to eq("${$myvar}")
+      expect(tokens[7].to_manifest).to eq('$myvar')
+
+      expect(tokens.map(&:to_manifest).join('')).to eq(manifest)
     end
   end
 
@@ -1157,48 +1370,48 @@ describe PuppetLint::Lexer do
     end
 
     it "should match a single quoted string with an escaped '" do
-      token = @lexer.tokenise(%q{'single quoted string with "\\'"'}).first
+      token = @lexer.tokenise(%q('single quoted string with "\\'"')).first
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq('single quoted string with "\\\'"')
     end
 
-    it "should match a single quoted string with an escaped $" do
-      token = @lexer.tokenise(%q{'single quoted string with "\$"'}).first
+    it 'should match a single quoted string with an escaped $' do
+      token = @lexer.tokenise(%q('single quoted string with "\$"')).first
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq('single quoted string with "\\$"')
     end
 
-    it "should match a single quoted string with an escaped ." do
-      token = @lexer.tokenise(%q{'single quoted string with "\."'}).first
+    it 'should match a single quoted string with an escaped .' do
+      token = @lexer.tokenise(%q('single quoted string with "\."')).first
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq('single quoted string with "\\."')
     end
 
-    it "should match a single quoted string with an escaped \\n" do
-      token = @lexer.tokenise(%q{'single quoted string with "\n"'}).first
+    it 'should match a single quoted string with an escaped \\n' do
+      token = @lexer.tokenise(%q('single quoted string with "\n"')).first
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq('single quoted string with "\\n"')
     end
 
-    it "should match a single quoted string with an escaped \\" do
-      token = @lexer.tokenise(%q{'single quoted string with "\\\\"'}).first
+    it 'should match a single quoted string with an escaped \\' do
+      token = @lexer.tokenise(%q('single quoted string with "\\\\"')).first
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq('single quoted string with "\\\\"')
     end
 
-    it "should match an empty string" do
+    it 'should match an empty string' do
       token = @lexer.tokenise("''").first
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq('')
     end
 
-    it "should match an empty string ending with \\\\" do
+    it 'should match an empty string ending with \\\\' do
       token = @lexer.tokenise("'foo\\\\'").first
       expect(token.type).to eq(:SSTRING)
-      expect(token.value).to eq(%{foo\\\\})
+      expect(token.value).to eq(%(foo\\\\))
     end
 
-    it "should match single quoted string containing a line break" do
+    it 'should match single quoted string containing a line break' do
       token = @lexer.tokenise("'\n'").first
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq("\n")
@@ -1259,20 +1472,20 @@ describe PuppetLint::Lexer do
   end
 
   context ':STRING' do
-    it 'should parse strings with \\\\\\' do
+    it 'should parse strings with embedded strings' do
       expect {
-        @lexer.tokenise("exec { \"/bin/echo \\\\\\\"${environment}\\\\\\\"\": }")
+        @lexer.tokenise('exec { "/bin/echo \"${environment}\"": }')
       }.to_not raise_error
     end
 
-    it "should match double quoted string containing a line break" do
-      token = @lexer.tokenise(%Q{"\n"}).first
+    it 'should match double quoted string containing a line break' do
+      token = @lexer.tokenise(%("\n")).first
       expect(token.type).to eq(:STRING)
       expect(token.value).to eq("\n")
     end
 
     it 'should handle interpolated values that contain double quotes' do
-      manifest = %Q{"export bar=\\"${join(hiera('test'), "," )}\\""}
+      manifest = %{"export bar=\\"${join(hiera('test'), "," )}\\""}
 
       tokens = @lexer.tokenise(manifest)
       expect(tokens[0].type).to eq(:DQPRE)
@@ -1298,4 +1511,24 @@ describe PuppetLint::Lexer do
       expect(tokens[12].value).to eq('\"')
     end
   end
+
+  context ':WHITESPACE' do
+    it 'should parse spaces' do
+      token = @lexer.tokenise(' ').first
+      expect(token.type).to eq(:WHITESPACE)
+      expect(token.value).to eq(' ')
+    end
+
+    it 'should parse tabs' do
+      token = @lexer.tokenise("\t").first
+      expect(token.type).to eq(:WHITESPACE)
+      expect(token.value).to eq("\t")
+    end
+
+    it 'should parse unicode spaces' do
+      token = @lexer.tokenise("\xc2\xa0").first
+      expect(token.type).to eq(:WHITESPACE)
+      expect(token.value).to eq("\xc2\xa0")
+    end
+  end
 end