puppet-lint 2.3.6 → 2.4.0

data/lib/puppet-lint/lexer/string_slurper.rb

@@ -0,0 +1,157 @@
+require 'strscan'
+
+class PuppetLint
+  class Lexer
+    # Document this
+    # TODO
+    class StringSlurper
+      class UnterminatedStringError < StandardError; end
+
+      attr_accessor :scanner
+      attr_accessor :results
+      attr_accessor :interp_stack
+
+      START_INTERP_PATTERN = %r{\$\{}
+      END_INTERP_PATTERN = %r{\}}
+      END_STRING_PATTERN = %r{(\A|[^\\])(\\\\)*"}
+      UNENC_VAR_PATTERN = %r{(\A|[^\\])\$(::)?(\w+(-\w+)*::)*\w+(-\w+)*}
+      ESC_DQUOTE_PATTERN = %r{\\+"}
+      LBRACE_PATTERN = %r{\{}
+
+      def initialize(string)
+        @scanner = StringScanner.new(string)
+        @results = []
+        @interp_stack = []
+        @segment = []
+      end
+
+      def parse
+        @segment_type = :STRING
+
+        until scanner.eos?
+          if scanner.match?(START_INTERP_PATTERN)
+            start_interp
+          elsif !interp_stack.empty? && scanner.match?(LBRACE_PATTERN)
+            read_char
+          elsif scanner.match?(END_INTERP_PATTERN)
+            end_interp
+          elsif unenclosed_variable?
+            unenclosed_variable
+          elsif scanner.match?(ESC_DQUOTE_PATTERN)
+            @segment << scanner.scan(ESC_DQUOTE_PATTERN)
+          elsif scanner.match?(END_STRING_PATTERN)
+            end_string
+            break if interp_stack.empty?
+          else
+            read_char
+          end
+        end
+
+        raise UnterminatedStringError if results.empty? && scanner.matched?
+
+        results
+      end
+
+      def unenclosed_variable?
+        interp_stack.empty? &&
+          scanner.match?(UNENC_VAR_PATTERN) &&
+          (@segment.last.nil? ? true : !@segment.last.end_with?('\\'))
+      end
+
+      def parse_heredoc(heredoc_tag)
+        heredoc_name = heredoc_tag[%r{\A"?(.+?)"?(:.+?)?#{PuppetLint::Lexer::WHITESPACE_RE}*(/.*)?\Z}, 1]
+        end_heredoc_pattern = %r{\A\|?\s*-?\s*#{Regexp.escape(heredoc_name)}}
+        interpolation = heredoc_tag.start_with?('"')
+
+        @segment_type = :HEREDOC
+
+        until scanner.eos?
+          if scanner.match?(end_heredoc_pattern)
+            end_heredoc(end_heredoc_pattern)
+            break if interp_stack.empty?
+          elsif interpolation && scanner.match?(START_INTERP_PATTERN)
+            start_interp
+          elsif interpolation && !interp_stack.empty? && scanner.match?(LBRACE_PATTERN)
+            read_char
+          elsif interpolation && unenclosed_variable?
+            unenclosed_variable
+          elsif interpolation && scanner.match?(END_INTERP_PATTERN)
+            end_interp
+          else
+            read_char
+          end
+        end
+
+        results
+      end
+
+      def read_char
+        @segment << scanner.getch
+
+        return if interp_stack.empty?
+
+        case @segment.last
+        when '{'
+          interp_stack.push(true)
+        when '}'
+          interp_stack.pop
+        end
+      end
+
+      def consumed_bytes
+        scanner.pos
+      end
+
+      def start_interp
+        if interp_stack.empty?
+          scanner.skip(START_INTERP_PATTERN)
+          results << [@segment_type, @segment.join]
+          @segment = []
+        else
+          @segment << scanner.scan(START_INTERP_PATTERN)
+        end
+
+        interp_stack.push(true)
+      end
+
+      def end_interp
+        if interp_stack.empty?
+          @segment << scanner.scan(END_INTERP_PATTERN)
+          return
+        else
+          interp_stack.pop
+        end
+
+        if interp_stack.empty?
+          results << [:INTERP, @segment.join]
+          @segment = []
+          scanner.skip(END_INTERP_PATTERN)
+        else
+          @segment << scanner.scan(END_INTERP_PATTERN)
+        end
+      end
+
+      def unenclosed_variable
+        read_char if scanner.match?(%r{.\$})
+
+        results << [@segment_type, @segment.join]
+        results << [:UNENC_VAR, scanner.scan(UNENC_VAR_PATTERN)]
+        @segment = []
+      end
+
+      def end_heredoc(pattern)
+        results << [:HEREDOC, @segment.join]
+        results << [:HEREDOC_TERM, scanner.scan(pattern)]
+      end
+
+      def end_string
+        if interp_stack.empty?
+          @segment << scanner.scan(END_STRING_PATTERN).gsub!(%r{"\Z}, '')
+          results << [@segment_type, @segment.join]
+        else
+          @segment << scanner.scan(END_STRING_PATTERN)
+        end
+      end
+    end
+  end
+end

data/lib/puppet-lint/lexer/token.rb

@@ -193,6 +193,8 @@ class PuppetLint
               token_iter = token_iter.send("#{direction}_token_of".to_sym, ["#{closing_token}PAREN".to_sym, opts])
             end
           end
+
+          return nil if token_iter.nil?
           token_iter = token_iter.send("#{direction}_token".to_sym)
         end
         nil

data/lib/puppet-lint/optparser.rb

@@ -18,7 +18,6 @@ class PuppetLint::OptParser
   #
   # Returns an OptionParser object.
   def self.build(args = [])
-    noconfig = false
     opt_parser = OptionParser.new do |opts|
       opts.banner = HELP_TEXT
 
@@ -27,7 +26,7 @@ class PuppetLint::OptParser
       end
 
       opts.on('--no-config', 'Do not load default puppet-lint option files.') do
-        noconfig = true
+        # nothing to do, option is handled differently
       end
 
       opts.on('-c', '--config FILE', 'Load puppet-lint options from file.') do |file|
@@ -134,9 +133,7 @@ class PuppetLint::OptParser
       end
     end
 
-    opt_parser.parse!(args) unless args.empty?
-
-    unless noconfig
+    unless args.include?('--no-config')
       opt_parser.load('/etc/puppet-lint.rc')
       if ENV.key?('HOME') && File.readable?(ENV['HOME'])
         home_dotfile_path = File.expand_path('~/.puppet-lint.rc')
@@ -145,6 +142,8 @@ class PuppetLint::OptParser
       opt_parser.load('.puppet-lint.rc')
     end
 
+    opt_parser.parse!(args) unless args.empty?
+
     opt_parser
   end
 end

data/lib/puppet-lint/plugins/check_conditionals/case_without_default.rb

@@ -31,7 +31,21 @@ PuppetLint.new_check(:case_without_default) do
         case_tokens -= tokens[successor_kase[:start]..successor_kase[:end]]
       end
 
-      next if case_tokens.index { |r| r.type == :DEFAULT }
+      found_matching_default = false
+      depth = 0
+
+      case_tokens.each do |token|
+        if token.type == :LBRACE
+          depth += 1
+        elsif token.type == :RBRACE
+          depth -= 1
+        elsif token.type == :DEFAULT && depth == 1
+          found_matching_default = true
+          break
+        end
+      end
+
+      next if found_matching_default
 
       notify(
         :warning,

data/lib/puppet-lint/plugins/check_resources/ensure_first_param.rb

@@ -29,9 +29,12 @@ PuppetLint.new_check(:ensure_first_param) do
     first_param_name_token = tokens[problem[:resource][:start]].next_token_of(:NAME)
     first_param_comma_token = first_param_name_token.next_token_of(:COMMA)
     ensure_param_name_token = first_param_comma_token.next_token_of(:NAME, :value => 'ensure')
+
+    raise PuppetLint::NoFix if ensure_param_name_token.nil?
+
     ensure_param_comma_token = ensure_param_name_token.next_token_of([:COMMA, :SEMIC])
 
-    if first_param_name_token.nil? || first_param_comma_token.nil? || ensure_param_name_token.nil? || ensure_param_comma_token.nil?
+    if first_param_name_token.nil? || first_param_comma_token.nil? || ensure_param_comma_token.nil?
       raise PuppetLint::NoFix
     end
 

data/lib/puppet-lint/plugins/check_strings/quoted_booleans.rb

@@ -25,3 +25,4 @@ PuppetLint.new_check(:quoted_booleans) do
     problem[:token].type = problem[:token].value.upcase.to_sym
   end
 end
+PuppetLint.configuration.send('disable_quoted_booleans')

data/lib/puppet-lint/plugins/check_strings/variables_not_enclosed.rb

@@ -1,9 +1,19 @@
+require 'set'
+require 'strscan'
+
 # Public: Check the manifest tokens for any variables in a string that have
 # not been enclosed by braces ({}) and record a warning for each instance
 # found.
 #
 # https://puppet.com/docs/puppet/latest/style_guide.html#quoting
 PuppetLint.new_check(:variables_not_enclosed) do
+  STRING_TOKEN_TYPES = Set[
+    :DQMID,
+    :DQPOST,
+    :HEREDOC_MID,
+    :HEREDOC_POST,
+  ]
+
   def check
     tokens.select { |r|
       r.type == :UNENC_VARIABLE
@@ -18,7 +28,68 @@ PuppetLint.new_check(:variables_not_enclosed) do
     end
   end
 
+  def hash_or_array_ref?(token)
+    token.next_token &&
+      STRING_TOKEN_TYPES.include?(token.next_token.type) &&
+      token.next_token.value.start_with?('[')
+  end
+
+  def extract_hash_or_array_ref(token)
+    scanner = StringScanner.new(token.value)
+
+    brack_depth = 0
+    result = { :ref => '' }
+
+    until scanner.eos?
+      result[:ref] += scanner.getch
+
+      # Pass a length of 1 when slicing the last character from the string
+      # to prevent Ruby 1.8 returning a Fixnum instead of a String.
+      case result[:ref][-1, 1]
+      when '['
+        brack_depth += 1
+      when ']'
+        brack_depth -= 1
+      end
+
+      break if brack_depth.zero? && scanner.peek(1) != '['
+    end
+
+    result[:remainder] = scanner.rest
+    result
+  end
+
+  def variable_contains_dash?(token)
+    token.value.include?('-')
+  end
+
+  def handle_variable_containing_dash(var_token)
+    str_token = var_token.next_token
+
+    var_name, text = var_token.value.split('-', 2)
+    var_token.value = var_name
+
+    return if str_token.nil?
+    str_token.value = "-#{text}#{str_token.value}"
+  end
+
   def fix(problem)
     problem[:token].type = :VARIABLE
+
+    if hash_or_array_ref?(problem[:token])
+      string_token = problem[:token].next_token
+      tokens_index = tokens.index(string_token)
+
+      hash_or_array_ref = extract_hash_or_array_ref(string_token)
+
+      ref_tokens = PuppetLint::Lexer.new.tokenise(hash_or_array_ref[:ref])
+      ref_tokens.each_with_index do |token, i|
+        add_token(tokens_index + i, token)
+      end
+
+      string_token.value = hash_or_array_ref[:remainder]
+    end
+
+    handle_variable_containing_dash(problem[:token]) if variable_contains_dash?(problem[:token])
   end
 end

data/lib/puppet-lint/plugins/check_whitespace/arrow_alignment.rb

@@ -51,7 +51,7 @@ PuppetLint.new_check(:arrow_alignment) do
             this_arrow_column = param_column[level_idx] + param_length + 1
           else
             this_arrow_column = param_token.column + param_token.to_manifest.length
-            this_arrow_column += 1 unless param_token.type == :DQPOST
+            this_arrow_column += 1
           end
 
           if arrow_column[level_idx] < this_arrow_column

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '2.3.6'.freeze
+  VERSION = '2.4.0'.freeze
 end

data/spec/fixtures/test/manifests/two_warnings.pp

@@ -0,0 +1,5 @@
+# foo
+define test::two_warnings() {
+  $var1-with-dash = 42
+  $VarUpperCase   = false
+}

data/spec/puppet-lint/bin_spec.rb

@@ -526,4 +526,45 @@ describe PuppetLint::Bin do
       end
     end
   end
+
+  context 'when overriding config file options with command line options' do
+    context 'and config file sets "--only-checks=variable_contains_dash"' do
+      around(:context) do |example|
+        Dir.mktmpdir do |tmpdir|
+          Dir.chdir(tmpdir) do
+            File.open('.puppet-lint.rc', 'wb') do |f|
+              f.puts('--only-checks=variable_contains_dash')
+            end
+
+            example.run
+          end
+        end
+      end
+
+      context 'and command-line does not override "--only-checks"' do
+        let(:args) do
+          File.join(File.dirname(__FILE__), '..', 'fixtures', 'test', 'manifests', 'two_warnings.pp')
+        end
+
+        its(:exitstatus) { is_expected.to eq(0) }
+        its(:stdout) do
+          is_expected.to eq('WARNING: variable contains a dash on line 3')
+        end
+      end
+
+      context 'and command-line sets "--only-checks=variable_is_lowercase"' do
+        let(:args) do
+          [
+            '--only-checks=variable_is_lowercase',
+            File.join(File.dirname(__FILE__), '..', 'fixtures', 'test', 'manifests', 'two_warnings.pp'),
+          ]
+        end
+
+        its(:exitstatus) { is_expected.to eq(0) }
+        its(:stdout) do
+          is_expected.to eq('WARNING: variable contains an uppercase letter on line 4')
+        end
+      end
+    end
+  end
 end

data/spec/puppet-lint/data_spec.rb

@@ -20,6 +20,18 @@ describe PuppetLint::Data do
         }
       end
     end
+
+    context 'when typo in namespace separator makes parser look for resource' do
+      let(:manifest) { '$testparam = $::module:;testparam' }
+
+      it 'raises a SyntaxError' do
+        expect {
+          data.resource_indexes
+        }.to raise_error(PuppetLint::SyntaxError) { |error|
+          expect(error.token).to eq(data.tokens[5])
+        }
+      end
+    end
   end
 
   describe '.insert' do

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

@@ -0,0 +1,407 @@
+require 'spec_helper'
+
+describe PuppetLint::Lexer::StringSlurper do
+  describe '#parse' do
+    subject(:segments) { described_class.new(string).parse }
+
+    context 'when parsing an unterminated string' do
+      let(:string) { 'foo' }
+
+      it 'raises an UnterminatedStringError' do
+        expect { segments }.to raise_error(described_class::UnterminatedStringError)
+      end
+    end
+
+    context 'when parsing up to a double quote' do
+      let(:string) { 'foo"bar' }
+
+      it 'returns a single segment up to the double quote' do
+        expect(segments).to eq([[:STRING, 'foo']])
+      end
+
+      context 'and the string is empty' do
+        let(:string) { '"' }
+
+        it 'returns a single empty string segment' do
+          expect(segments).to eq([[:STRING, '']])
+        end
+      end
+
+      context 'and the string contains' do
+        context 'a newline' do
+          let(:string) { %(foo\nbar") }
+
+          it 'includes the newline in the string segment' do
+            expect(segments).to eq([[:STRING, "foo\nbar"]])
+          end
+        end
+
+        context 'an escaped $' do
+          let(:string) { '\$foo"' }
+
+          it 'does not create an interpolation segment' do
+            expect(segments).to eq([[:STRING, '\$foo']])
+          end
+        end
+
+        context 'a variable and a suffix' do
+          let(:string) { '${foo}bar"' }
+
+          it 'puts the variable into an interpolation segment' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'foo'],
+              [:STRING, 'bar'],
+            ])
+          end
+        end
+
+        context 'a variable surrounded by text' do
+          let(:string) { 'foo${bar}baz"' }
+
+          it 'puts the variable into an interpolation segment' do
+            expect(segments).to eq([
+              [:STRING, 'foo'],
+              [:INTERP, 'bar'],
+              [:STRING, 'baz'],
+            ])
+          end
+        end
+
+        context 'multiple variables with surrounding text' do
+          let(:string) { 'foo${bar}baz${gronk}meh"' }
+
+          it 'puts each variable into an interpolation segment' do
+            expect(segments).to eq([
+              [:STRING, 'foo'],
+              [:INTERP, 'bar'],
+              [:STRING, 'baz'],
+              [:INTERP, 'gronk'],
+              [:STRING, 'meh'],
+            ])
+          end
+        end
+
+        context 'only an enclosed variable' do
+          let(:string) { '${bar}"' }
+
+          it 'puts empty string segments around the interpolated segment' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'bar'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'an enclosed variable with an unnecessary $' do
+          let(:string) { '${$bar}"' }
+
+          it 'does not remove the unnecessary $' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, '$bar'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'a variable with an array reference' do
+          let(:string) { '${foo[bar][baz]}"' }
+
+          it 'includes the references in the interpolated section' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'foo[bar][baz]'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'only enclosed variables' do
+          let(:string) { '${foo}${bar}"' }
+
+          it 'creates an interpolation section per variable' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'foo'],
+              [:STRING, ''],
+              [:INTERP, 'bar'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'an unenclosed variable' do
+          let(:string) { '$foo"' }
+
+          it 'creates a special segment for the unenclosed variable' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:UNENC_VAR, '$foo'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'an interpolation with a nested single quoted string' do
+          let(:string) { %(string with ${'a nested single quoted string'} inside it") }
+
+          it 'creates an interpolation segment for the nested string' do
+            expect(segments).to eq([
+              [:STRING, 'string with '],
+              [:INTERP, "'a nested single quoted string'"],
+              [:STRING, ' inside it'],
+            ])
+          end
+        end
+
+        context 'an interpolation with nested math' do
+          let(:string) { 'string with ${(3+5)/4} nested math"' }
+
+          it 'creates an interpolation segment for the nested math' do
+            expect(segments).to eq([
+              [:STRING, 'string with '],
+              [:INTERP, '(3+5)/4'],
+              [:STRING, ' nested math'],
+            ])
+          end
+        end
+
+        context 'an interpolation with a nested array' do
+          let(:string) { %(string with ${['an array ', $v2]} in it") }
+
+          it 'creates an interpolation segment for the nested array' do
+            expect(segments).to eq([
+              [:STRING, 'string with '],
+              [:INTERP, "['an array ', $v2]"],
+              [:STRING, ' in it'],
+            ])
+          end
+        end
+
+        context 'repeated $s' do
+          let(:string) { '$$$$"' }
+
+          it 'creates a single string segment' do
+            expect(segments).to eq([[:STRING, '$$$$']])
+          end
+        end
+
+        context 'multiple unenclosed variables' do
+          let(:string) { '$foo$bar"' }
+
+          it 'creates a special segment for each unenclosed variable' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:UNENC_VAR, '$foo'],
+              [:STRING, ''],
+              [:UNENC_VAR, '$bar'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'an unenclosed variable with a trailing $' do
+          let(:string) { 'foo$bar$"' }
+
+          it 'places the trailing $ in a string segment' do
+            expect(segments).to eq([
+              [:STRING, 'foo'],
+              [:UNENC_VAR, '$bar'],
+              [:STRING, '$'],
+            ])
+          end
+        end
+
+        context 'an unenclosed variable starting with two $s' do
+          let(:string) { 'foo$$bar"' }
+
+          it 'includes the preceeding $ in the string segment before the unenclosed variable' do
+            expect(segments).to eq([
+              [:STRING, 'foo$'],
+              [:UNENC_VAR, '$bar'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'an unenclosed variable with incorrect namespacing' do
+          let(:string) { '$foo::::bar"' }
+
+          it 'only includes the valid part of the variable name in the segment' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:UNENC_VAR, '$foo'],
+              [:STRING, '::::bar'],
+            ])
+          end
+        end
+
+        context 'an interpolation with a complex function chain' do
+          let(:string) { '${key} ${flatten([$value]).join("\nkey ")}"' }
+
+          it 'keeps the whole function chain in a single interpolation segment' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'key'],
+              [:STRING, ' '],
+              [:INTERP, 'flatten([$value]).join("\nkey ")'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'nested interpolations' do
+          let(:string) { '${facts["network_${iface}"]}/${facts["netmask_${iface}"]}"' }
+
+          it 'keeps each full interpolation in its own segment' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'facts["network_${iface}"]'],
+              [:STRING, '/'],
+              [:INTERP, 'facts["netmask_${iface}"]'],
+              [:STRING, ''],
+            ])
+          end
+        end
+
+        context 'interpolation with nested braces' do
+          let(:string) { '${$foo.map |$bar| { something($bar) }}"' }
+
+          it do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, '$foo.map |$bar| { something($bar) }'],
+              [:STRING, ''],
+            ])
+          end
+        end
+      end
+    end
+  end
+
+  describe '#parse_heredoc' do
+    subject(:segments) { described_class.new(heredoc).parse_heredoc(heredoc_tag) }
+
+    context 'when parsing a heredoc with interpolation disabled' do
+      context 'that is a plain heredoc' do
+        let(:heredoc) { %(  SOMETHING\n  ELSE\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { 'myheredoc' }
+
+        it 'splits the heredoc into two segments' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  ELSE\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+
+      context 'that contains a value enclosed in ${}' do
+        let(:heredoc) { %(  SOMETHING\n  ${else}\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { 'myheredoc' }
+
+        it 'does not create an interpolation segment' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  ${else}\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+
+      context 'that contains an unenclosed variable' do
+        let(:heredoc) { %(  SOMETHING\n  $else\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { 'myheredoc' }
+
+        it 'does not create a segment for the unenclosed variable' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  $else\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+    end
+
+    context 'when parsing a heredoc with interpolation enabled' do
+      context 'that is a plain heredoc' do
+        let(:heredoc) { %(  SOMETHING\n  ELSE\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { '"myheredoc"' }
+
+        it 'splits the heredoc into two segments' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  ELSE\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+
+      context 'that contains a value enclosed in ${}' do
+        let(:heredoc) { %(  SOMETHING\n  ${else}\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { '"myheredoc"' }
+
+        it 'creates an interpolation segment' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  "],
+            [:INTERP, 'else'],
+            [:HEREDOC, "\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+
+      context 'that contains an unenclosed variable' do
+        let(:heredoc) { %(  SOMETHING\n  $else\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { '"myheredoc"' }
+
+        it 'does not create a segment for the unenclosed variable' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  "],
+            [:UNENC_VAR, '$else'],
+            [:HEREDOC, "\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+
+      context 'that contains a nested interpolation' do
+        let(:heredoc) { %(  SOMETHING\n  ${facts["other_${thing}"]}\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { '"myheredoc"' }
+
+        it 'does not create a segment for the unenclosed variable' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  "],
+            [:INTERP, 'facts["other_${thing}"]'],
+            [:HEREDOC, "\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+
+      context 'that contains an interpolation with nested braces' do
+        let(:heredoc) { %(  SOMETHING\n  ${$foo.map |$bar| { something($bar) }}\n  :\n  |-myheredoc) }
+        let(:heredoc_tag) { '"myheredoc"' }
+
+        it 'does not create a segment for the unenclosed variable' do
+          expect(segments).to eq([
+            [:HEREDOC, "  SOMETHING\n  "],
+            [:INTERP, '$foo.map |$bar| { something($bar) }'],
+            [:HEREDOC, "\n  :\n  "],
+            [:HEREDOC_TERM, '|-myheredoc'],
+          ])
+        end
+      end
+
+      context 'that contains braces' do
+        let(:heredoc) { %(  {\n    "foo": "bar"\n  }\n  |-end) }
+        let(:heredoc_tag) { '"end":json/' }
+
+        it do
+          expect(segments).to eq([
+            [:HEREDOC, %(  {\n    "foo": "bar"\n  }\n  )],
+            [:HEREDOC_TERM, '|-end'],
+          ])
+        end
+      end
+    end
+  end
+end