puppet-lint-array_formatting-check 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c130a6b549e23b5a62141163214c8dc669e2ec4cf4e2969773a853bf490d60e7
+  data.tar.gz: d4233449808f9190aa3683639a99586ad89417280c370c256262d8af40a3e8aa
+SHA512:
+  metadata.gz: fee2c7bccde0fcf12cd2e1187556cc5ba2531ce7063f266da5fc309de07e01236f5d9e696991d3af19e824b54b2b7892a9e4c44b8f9a21f0b7379a086c876805
+  data.tar.gz: 6e198fc7fa4705566971abe7a486af1653cf43e3c85ffb0794c61e003528655358a444b64f727cbf5cf7da67a6bbf46571b4524d3b4aa1d7794406d1e7d41f70

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Adam Manzer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# puppet-lint array formatting check
+
+A new check for puppet-lint that ensures array formatting conforms to the [Puppet Style Guide](https://puppet.com/docs/puppet/6.0/style_guide.html#arrays-and-hashes) on arrays; namely that each element should be on a separate line.
+
+It will take an array formatted as
+
+```puppet
+$packages = [ 'vim', 'sl', 'bind-utils', ]
+```
+
+and ensure that it's formatted as
+
+```puppet
+$packages = [
+  'vim',
+  'sl',
+  'bind-utils',
+]
+```
+
+In the name of readability, it'll ignore arrays with one element.
+
+```puppet
+$my_short_package_list = [ 'emacs', ] 
+```
+
+## Installation
+
+To use this plugin, add the following line to your Gemfile
+
+```ruby
+gem 'puppet-lint-array_formatting-check'
+```
+
+and then run `bundle install`.
+
+You can also install it at a user level using
+
+```bash
+gem install --user-install puppet-lint-array_formatting-check
+```
+
+or at a system level using
+
+```bash
+sudo gem install puppet-lint-array_formatting-check
+```
+
+## Usage
+
+This plugin provides a new check to `puppet-lint`.
+
+### array-formatting
+
+**--fix support: Yes**
+
+This check will raise warnings for every element in an array that should be on its own line
+
+```
+WARNING: expected newline before element
+```
+
+It will also flag instances of extra newlines in arrays
+
+```
+WARNING: unexpected newline
+```
+
+### Author
+
+[Adam Manzer](https://gitlab.com/amanzer)

data/lib/puppet-lint/plugins/check_array_formatting.rb

@@ -0,0 +1,133 @@
+PuppetLint.new_check(:array_formatting) do
+  def process_array
+    # When we arrive here, the @manifest enumerator is "pointing" to
+    # the opening LBRACK.  Start by iterating that to point to the
+    # first element of the array:
+    token = @manifest.next
+    manifest_array = []
+    len_of_nested_array = 0
+
+    # Scan through the manifest until we encounter a RBRACK to close this array
+    until [:RBRACK].include?(token.type) || token.nil?
+      # If we encounter an LBRACK, we need to get our recursion on
+      if [:LBRACK].include?(token.type)
+        # Push the opening of the array as a placeholder unless the last token was a classref.
+        # If it was, it was already pushed, so skip pushing.
+        # We want to treat a classref and an array opening as a single token.
+        manifest_array.push token unless %i[CLASSREF TYPE].include?(token.prev_code_token.type)
+        # Recursively process this nested array.
+        # Store return so we know if the child array was processed or not.
+        len_of_nested_array = process_array
+      # If we encounter something _other_ than COMMA, WHITESPACE, or INDENT, push it.
+      # These don't include NEWLINE(s), which is what we need to keep track of.
+      elsif !%i[COMMA WHITESPACE INDENT].include?(token.type)
+        manifest_array.push token
+      end
+      # Advance.  (We're still looking for that RBRACK)
+      token = @manifest.next
+    end
+
+    # We've found the RBRACK, and built a copy of the array in the Puppet manifest in the
+    # local variable manifest_array.  Before we start validating, let's try to return early.
+    #
+    # Check the number of objects (tokens + newlines) we found, including child arrays.
+    # If it's one or less, we can leave and return that we're *not* formatting
+    return manifest_array.length if (manifest_array.length < 2) && (len_of_nested_array < 2)
+
+    # Array is 2 or more elements. Time to validate it.
+    #
+    # First element of the array should be a NEWLINE.
+    prev_token_was_newline = false
+
+    # Start iterating our rebuilt array
+    manifest_array.each_index do |x|
+      if !prev_token_was_newline && [:NEWLINE].include?(manifest_array[x].type)
+        # We were expecting a newline, so yay
+        prev_token_was_newline = true
+      elsif prev_token_was_newline && ![:NEWLINE].include?(manifest_array[x].type)
+        # We were expecting something other than a newline, so yay
+        prev_token_was_newline = false
+      elsif !prev_token_was_newline && ![:NEWLINE].include?(manifest_array[x].type)
+        # We were expecting a newline. :-(
+        notify :warning,
+               message: 'expected newline before element',
+               line: manifest_array[x].line,
+               column: manifest_array[x].column,
+               token: manifest_array[x]
+        # prev_token_was_newline is already false, so this isn't required
+        # prev_token_was_newline = false
+      elsif prev_token_was_newline && [:NEWLINE].include?(manifest_array[x].type)
+        # We got an extra newline. Let's fix that up while we're at it.
+        notify :warning,
+               message: 'unexpected newline',
+               line: manifest_array[x].line,
+               column: manifest_array[x].column,
+               token: manifest_array[x]
+        # prev_token_was_newline is already true, so this isn't required
+        # prev_token_was_newline = true
+      else
+        # Something has gone horribly wrong.  The truth table says we should never be here.
+        notify :error,
+               message: 'parsing error',
+               line: manifest_array[x].line,
+               column: manifest_array[x].column
+      end
+      # Next manifest_array item
+    end
+
+    # All elements of the array are done.
+    # If the last token (not including the RBRACK) wasn't a newline, throw a warning.
+    # Since we previously used token to scan forward to the ],
+    # token is already pointing to the offending ].
+    if !prev_token_was_newline # rubocop:disable NegatedIf "I find this clearer than `unless prev_token_was_newline`"
+      notify :warning,
+             message: 'expected newline before close',
+             line: token.line,
+             column: token.column,
+             token: token
+    end
+
+    # Return the length of the array so we can make assumptions about
+    # whether we're formatting or not
+    manifest_array.length
+  end
+
+  def check
+    # Create an instance-scope enumerator to walk through the Puppet manifest
+    @manifest = tokens.each
+    loop do
+      token = @manifest.next
+      next unless [:LBRACK].include?(token.type)
+
+      # Found an array!  Send if off for processing unless it's actually a Classref.
+      # We can disregard the return, becuase this is a top level array, and has no 'parent' to affect
+      process_array unless %i[CLASSREF TYPE].include?(token.prev_code_token.type)
+    end
+  end
+
+  def fix(problem)
+    token_index = tokens.find_index(problem[:token])
+    case problem[:message]
+    when 'parsing error'
+      # Truth table says we should never get here
+      raise PuppetLint::NoFix
+    when 'unexpected newline'
+      # If we delete the INDENT first, we change the index of the offending token,
+      # so we need to do the token first, then the INDENT
+      tokens.delete_at(token_index)
+      # If the previous token is an Indent, we'll want to delete that too
+      tokens.delete_at(token_index - 1) if [:INDENT].include?(problem[:token].prev_token.type)
+    when 'expected newline before element', 'expected newline before close'
+      # If the preceeding token is a whitespace, replace it with a newline instead
+      # so that we don't end up with trailing whitespaces
+      if %i[WHITESPACE INDENT].include?(problem[:token].prev_token.type)
+        problem[:token].prev_token.type = :NEWLINE
+      else
+        # Create a new Puppet Token object and insert it into the Puppet manifest in the correct location.
+        # The location specified in Token.new() apparently doesn't matter since we're manually inserting it
+        # into the Tokens array at the proper position using token_index.
+        tokens.insert(token_index, PuppetLint::Lexer::Token.new(:NEWLINE, '\n', 0, 0))
+      end
+    end
+  end
+end

data/spec/puppet-lint/plugins/check_array_formatting_spec.rb

@@ -0,0 +1,1023 @@
+# Rubocop has a problem with some of my examples.
+# Since they're Puppet code, inside a ruby file,
+# I'm going to blame different syntaxes.
+# rubocop:disable TrailingCommaInArguments
+require 'spec_helper'
+
+describe 'array_formatting' do
+  let(:msg) { 'expected newline before element' }
+  let(:msg_end) { 'expected newline before close' }
+  let(:msg_newline) { 'unexpected newline' }
+
+  context 'with fix disabled' do
+    context 'on code with an empty array' do
+      let(:code) { '$services = []' }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with a single-item array' do
+      let(:code) { "$my_string = [ 'a' ]" }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with a single-item array with a comma' do
+      let(:code) { "$my_string = [ 'a', ]" }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with a triple-nested array of weirdness' do
+      let(:code) { '$my_array = [[[ 1 ]]]' }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with a properly formatted array of numbers' do
+      let(:code) do
+        # Removes the 10 indentation spaces by replacing them with nothing
+        # Thanks to Marius Rieder in check_strict_indent_spec
+        <<-ARRAY.gsub(/^ {10}/, '')
+          $my_numbers = [
+            1,
+            2,
+            3,
+          ]
+        ARRAY
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with a spaced single-line array' do
+      let(:code) { "$my_strings = [ 'a', \"b\", 'c', 4, ]" }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should create a warning' do
+        # There should be a warning message, matching the
+        # message above, flagged after the opening '['
+        expect(problems).to contain_warning(msg).on_line(1).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(22)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(27)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(32)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(35)
+      end
+    end
+    context 'on code with an unspaced single-line array' do
+      let(:code) { "$my_strings = ['a','b','c',4]" }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should create a warning' do
+        # There should be a warning message, matching the
+        # message above, flagged after the opening '['
+        expect(problems).to contain_warning(msg).on_line(1).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(20)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(24)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(28)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(29)
+      end
+    end
+    context 'on code with an inconsistently separated array' do
+      let(:code) do
+        <<-ARRAY.gsub(/^ {10}/, '')
+          file{[
+            '/etc', '/etc/app',
+            '/opt', '/opt/app',
+          ]:
+            ensure => directory,
+          }
+        ARRAY
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(2).in_column(11)
+        expect(problems).to contain_warning(msg).on_line(3).in_column(11)
+      end
+    end
+    context 'on code with an array with extra newlines' do
+      let(:code) do
+        # rubocop:disable TrailingWhitespace
+        <<-ARRAY.gsub(/^ {10}/, '')
+          file{[
+            '/etc',
+            
+            '/etc/app',
+            '/opt',
+            
+            '/opt/app',
+          ]:
+            ensure => directory,
+          }
+        ARRAY
+        # rubocop:enable TrailingWhitespace
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg_newline).on_line(3).in_column(3)
+        expect(problems).to contain_warning(msg_newline).on_line(6).in_column(3)
+      end
+    end
+    context 'on code with a single child array of two elements' do
+      let(:code) { '$my_array = [[ 1, 2 ]]' }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(14)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(19)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(21)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(22)
+      end
+    end
+    context 'on code with a two array-element array' do
+      let(:code) { "$my_array = [ [1], ['a',] ]" }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(20)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(27)
+      end
+    end
+    context 'on code with an array with a two-element array nested second' do
+      let(:code) { "$my_array = [ [1], ['a', 'b'] ]" }
+
+      it 'should detect 6 problems' do
+        expect(problems).to have(6).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(20)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(21)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(26)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(29)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(31)
+      end
+    end
+    context 'on code with an array with a two-element array nested first' do
+      let(:code) { "$my_array = [ [1,2], ['a',] ]" }
+
+      it 'should detect 6 problems' do
+        expect(problems).to have(6).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(18)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(19)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(22)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(29)
+      end
+    end
+    context 'on code with a single-value classref' do
+      let(:code) { "subscribe => File['/etc/fstab']" }
+
+      it 'should detect no problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with a single-value classref in an array' do
+      let(:code) { "subscribe => [File['/etc/fstab'],]" }
+
+      it 'should detect no problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with a multi-classref array' do
+      let(:code) { "subscribe => [File['/etc/fstab'], Service['sshd'],]" }
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(35)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(51)
+      end
+    end
+    context 'on code with a nested classref array' do
+      let(:code) { "subscribe => [ File['/etc/fstab','/etc/auto.master',] ]," }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(21)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(34)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(53)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(55)
+      end
+    end
+    context 'on code with an array of  multiple classrefs' do
+      let(:code) { "subscribe => [File['/etc/fstab','/etc/auto.master'], Service['sshd'],]" }
+
+      it 'should detect six problems' do
+        expect(problems).to have(6).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(20)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(33)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(51)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(54)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(70)
+      end
+    end
+    context 'on code with an array of 2 two-value classrefs' do
+      let(:code) { "subscribe => [File['/etc/fstab','/etc/auto.master'], Service['sshd',$ntp::service],]" }
+
+      it 'should detect six problems' do
+        expect(problems).to have(9).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(20)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(33)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(51)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(54)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(62)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(69)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(82)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(84)
+      end
+    end
+    context 'on code with an Enum' do
+      let(:code) { 'Enum[3.3, 5] $voltage' }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on code with six different arrays' do
+      let(:code) do
+        <<-CODE.gsub(/^ {10}/, '')
+          $file_list1 = ['/etc/file1', '/etc/file2']
+          $file_list2 = ['/etc/file3',]
+          $file_list3 = ['/etc/file4', '/etc/file5',]
+          file{[ $file_list1,
+            $file_list2, $file_list3,
+          ]:
+            ensure    => directory,
+            subscribe => [File[$file_list1, $file_list2]]
+            notify    => [File[$file_list2, $file_list3]]
+          }
+        CODE
+      end
+
+      it 'should detect 18 problems' do
+        expect(problems).to have(18).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(30)
+        expect(problems).to contain_warning(msg_end).on_line(1).in_column(42)
+        expect(problems).to contain_warning(msg).on_line(3).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(3).in_column(30)
+        expect(problems).to contain_warning(msg_end).on_line(3).in_column(43)
+        expect(problems).to contain_warning(msg).on_line(4).in_column(8)
+        expect(problems).to contain_warning(msg).on_line(5).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(8).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(8).in_column(22)
+        expect(problems).to contain_warning(msg).on_line(8).in_column(35)
+        expect(problems).to contain_warning(msg_end).on_line(8).in_column(46)
+        expect(problems).to contain_warning(msg_end).on_line(8).in_column(47)
+        expect(problems).to contain_warning(msg).on_line(9).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(9).in_column(22)
+        expect(problems).to contain_warning(msg).on_line(9).in_column(35)
+        expect(problems).to contain_warning(msg_end).on_line(9).in_column(46)
+        expect(problems).to contain_warning(msg_end).on_line(9).in_column(47)
+      end
+    end
+    context 'on a complete code example with no issues' do
+      let(:code) do
+        <<-CODE.gsub(/^ {10}/, '')
+          class testing(
+            Enum['present', 'absent'] $package_ensure,
+            Array[String] $keys,
+            Boolean $keys_enable,
+            Optional[Integer[0]] $panic,
+            Optional[Array[String]] $pool,
+            Variant[Boolean, Integer[0,1]] $tos_cohort,
+          ) {
+            if $facts['is_virtual'] {
+              $_tinker = pick($tinker, true)
+            } else {
+              $tinker = pick($tinker, false)
+            }
+            Class['::ntp::install']
+            -> Class['::ntp::config']
+            ~> Class['::ntp::service']
+          }
+        CODE
+      end
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+    end
+    context 'on a complete code example with one bad array' do
+      let(:code) do
+        <<-CODE.gsub(/^ {10}/, '')
+          class testing(
+            Enum['present', 'absent'] $package_ensure,
+            Array[String] $keys,
+            Boolean $keys_enable,
+            Optional[Integer[0]] $panic,
+            Optional[Array[String]] $pool,
+            Variant[Boolean, Integer[0,1]] $tos_cohort,
+          ) {
+            if $facts['is_virtual'] {
+              $_tinker = pick($tinker, true)
+            } else {
+              $tinker = pick($tinker, false)
+            }
+            $keys_parameters = [$keys, $keys_enable]
+            Class['::ntp::install']
+            -> Class['::ntp::config']
+            ~> Class['::ntp::service']
+          }
+        CODE
+      end
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create warnings' do
+        expect(problems).to contain_warning(msg).on_line(14).in_column(23)
+        expect(problems).to contain_warning(msg).on_line(14).in_column(30)
+        expect(problems).to contain_warning(msg_end).on_line(14).in_column(42)
+      end
+    end
+  end
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+    context 'on code with an empty array' do
+      let(:code) { '$services = []' }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with a single-item array' do
+      let(:code) { "$my_string = [ 'a' ]" }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with a single-item array with a comma' do
+      let(:code) { "$my_string = [ 'a', ]" }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with a triple-nested array of weirdness' do
+      let(:code) { '$my_array = [[[ 1 ]]]' }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with a properly formatted array of numbers' do
+      let(:code) do
+        # Removes the 10 indentation spaces by replacing them with nothing
+        # Thanks to Marius Rieder in check_strict_indent_spec
+        <<-ARRAY.gsub(/^ {10}/, '')
+          $my_numbers = [
+            1,
+            2,
+            3,
+          ]
+        ARRAY
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with a spaced single-line array' do
+      let(:code) { "$my_strings = [ 'a', \"b\", 'c', 4, ]" }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should generate fixes' do
+        # There should be a warning message, matching the
+        # message above, flagged after the opening '['
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(22)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(27)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(32)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(35)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq("$my_strings = [\n'a',\n\"b\",\n'c',\n4,\n]")
+      end
+    end
+    context 'on code with an unspaced single-line array' do
+      let(:code) { "$my_strings = ['a','b','c',4]" }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should generate fixes' do
+        # There should be a warning message, matching the
+        # message above, flagged after the opening '['
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(20)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(24)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(28)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(29)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq("$my_strings = [\n'a',\n'b',\n'c',\n4\n]")
+      end
+    end
+    context 'on code with an inconsistently separated array' do
+      let(:code) do
+        <<-ARRAY.gsub(/^ {10}/, '')
+          file{[
+            '/etc', '/etc/app',
+            '/opt', '/opt/app',
+          ]:
+            ensure => directory,
+          }
+        ARRAY
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create fixes ' do
+        expect(problems).to contain_fixed(msg).on_line(2).in_column(11)
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(11)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          # This is the expected code. This plugin doesn't do indentation, so it's expected
+          # that the moved lines will be "bad" indentation.  Hopefully the indentation fixer
+          # can run after this plugin.
+          <<-ARRAY.gsub(/^ {12}/, '')
+            file{[
+              '/etc',
+            '/etc/app',
+              '/opt',
+            '/opt/app',
+            ]:
+              ensure => directory,
+            }
+          ARRAY
+        )
+      end
+    end
+    context 'on code with an array with extra newlines' do
+      let(:code) do
+        # rubocop:disable TrailingWhitespace
+        <<-ARRAY.gsub(/^ {10}/, '')
+          file{[
+            '/etc',
+            
+            '/etc/app',
+            '/opt',
+            
+            '/opt/app',
+          ]:
+            ensure => directory,
+          }
+        ARRAY
+        # rubocop:enable TrailingWhitespace
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg_newline).on_line(3).in_column(3)
+        expect(problems).to contain_fixed(msg_newline).on_line(6).in_column(3)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          <<-ARRAY.gsub(/^ {12}/, '')
+            file{[
+              '/etc',
+              '/etc/app',
+              '/opt',
+              '/opt/app',
+            ]:
+              ensure => directory,
+            }
+          ARRAY
+        )
+      end
+    end
+    context 'on code with a single child array of two elements' do
+      let(:code) { '$my_array = [[ 1, 2 ]]' }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(14)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(19)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(21)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(22)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          # Again, this plugin doesn't indent
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            $my_array = [
+            [
+            1,
+            2
+            ]
+            ]
+          ARRAY
+        )
+      end
+    end
+    context 'on code with a two array-element array' do
+      let(:code) { "$my_array = [ [1], ['a',] ]" }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(20)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(27)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          # Again, this plugin doesn't indent
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            $my_array = [
+            [1],
+            ['a',]
+            ]
+          ARRAY
+        )
+      end
+    end
+    context 'on code with an array with a two-element array nested second' do
+      let(:code) { "$my_array = [ [1], ['a', 'b'] ]" }
+
+      it 'should detect 6 problems' do
+        expect(problems).to have(6).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(20)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(21)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(26)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(29)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(31)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          # Again, this plugin doesn't indent
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            $my_array = [
+            [1],
+            [
+            'a',
+            'b'
+            ]
+            ]
+          ARRAY
+        )
+      end
+    end
+    context 'on code with an array with a two-element array nested first' do
+      let(:code) { "$my_array = [ [1,2], ['a',] ]" }
+
+      it 'should detect 6 problems' do
+        expect(problems).to have(6).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(18)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(19)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(22)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(29)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          # Again, this plugin doesn't indent
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            $my_array = [
+            [
+            1,
+            2
+            ],
+            ['a',]
+            ]
+          ARRAY
+        )
+      end
+    end
+    context 'on code with a single-value classref' do
+      let(:code) { "subscribe => File['/etc/fstab']" }
+
+      it 'should detect no problems' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with a single-value classref in an array' do
+      let(:code) { "subscribe => [File['/etc/fstab'],]" }
+
+      it 'should detect no problems' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with a multi-classref array' do
+      let(:code) { "subscribe => [File['/etc/fstab'], Service['sshd'],]" }
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(35)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(51)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            subscribe => [
+            File['/etc/fstab'],
+            Service['sshd'],
+            ]
+          ARRAY
+        )
+      end
+    end
+    context 'on code with a nested classref array' do
+      let(:code) { "subscribe => [ File['/etc/fstab','/etc/auto.master',] ]," }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(21)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(34)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(53)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(55)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            subscribe => [
+            File[
+            '/etc/fstab',
+            '/etc/auto.master',
+            ]
+            ],
+          ARRAY
+        )
+      end
+    end
+    context 'on code with an array of  multiple classrefs' do
+      let(:code) { "subscribe => [File['/etc/fstab','/etc/auto.master'], Service['sshd'],]" }
+
+      it 'should detect six problems' do
+        expect(problems).to have(6).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(20)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(33)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(51)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(54)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(70)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            subscribe => [
+            File[
+            '/etc/fstab',
+            '/etc/auto.master'
+            ],
+            Service['sshd'],
+            ]
+          ARRAY
+        )
+      end
+    end
+    context 'on code with an array of 2 two-value classrefs' do
+      let(:code) { "subscribe => [File['/etc/fstab','/etc/auto.master'], Service['sshd',$ntp::service],]" }
+
+      it 'should detect six problems' do
+        expect(problems).to have(9).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(20)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(33)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(51)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(54)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(62)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(69)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(82)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(84)
+      end
+
+      it 'should properly format the array' do
+        expect(manifest).to eq(
+          <<-ARRAY.chomp.gsub(/^ {12}/, '')
+            subscribe => [
+            File[
+            '/etc/fstab',
+            '/etc/auto.master'
+            ],
+            Service[
+            'sshd',
+            $ntp::service
+            ],
+            ]
+          ARRAY
+        )
+      end
+    end
+    context 'on code fragment with an Enum' do
+      let(:code) { 'Enum[3.3, 5] $voltage' }
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on code with six different arrays' do
+      let(:code) do
+        <<-CODE.gsub(/^ {10}/, '')
+          $file_list1 = ['/etc/file1', '/etc/file2']
+          $file_list2 = ['/etc/file3',]
+          $file_list3 = ['/etc/file4', '/etc/file5',]
+          file{[ $file_list1,
+            $file_list2, $file_list3,
+          ]:
+            ensure    => directory,
+            subscribe => [File[$file_list1, $file_list2]]
+            notify    => [File[$file_list2, $file_list3]]
+          }
+        CODE
+      end
+
+      it 'should detect 18 problems' do
+        expect(problems).to have(18).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(30)
+        expect(problems).to contain_fixed(msg_end).on_line(1).in_column(42)
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(30)
+        expect(problems).to contain_fixed(msg_end).on_line(3).in_column(43)
+        expect(problems).to contain_fixed(msg).on_line(4).in_column(8)
+        expect(problems).to contain_fixed(msg).on_line(5).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(8).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(8).in_column(22)
+        expect(problems).to contain_fixed(msg).on_line(8).in_column(35)
+        expect(problems).to contain_fixed(msg_end).on_line(8).in_column(46)
+        expect(problems).to contain_fixed(msg_end).on_line(8).in_column(47)
+        expect(problems).to contain_fixed(msg).on_line(9).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(9).in_column(22)
+        expect(problems).to contain_fixed(msg).on_line(9).in_column(35)
+        expect(problems).to contain_fixed(msg_end).on_line(9).in_column(46)
+        expect(problems).to contain_fixed(msg_end).on_line(9).in_column(47)
+      end
+
+      it 'should properly format the code' do
+        # Don't forget this plugin doesn't do indentation, and the $file_list2 use below was
+        # already properly indented in the original code
+        expect(manifest).to eq(
+          <<-CODE.gsub(/^ {12}/, '')
+            $file_list1 = [
+            '/etc/file1',
+            '/etc/file2'
+            ]
+            $file_list2 = ['/etc/file3',]
+            $file_list3 = [
+            '/etc/file4',
+            '/etc/file5',
+            ]
+            file{[
+            $file_list1,
+              $file_list2,
+            $file_list3,
+            ]:
+              ensure    => directory,
+              subscribe => [
+            File[
+            $file_list1,
+            $file_list2
+            ]
+            ]
+              notify    => [
+            File[
+            $file_list2,
+            $file_list3
+            ]
+            ]
+            }
+          CODE
+        )
+      end
+    end
+    context 'on a complete code example with no issues' do
+      let(:code) do
+        <<-CODE.gsub(/^ {10}/, '')
+          class testing(
+            Enum['present', 'absent'] $package_ensure,
+            Array[String] $keys,
+            Boolean $keys_enable,
+            Optional[Integer[0]] $panic,
+            Optional[Array[String]] $pool,
+            Variant[Boolean, Integer[0,1]] $tos_cohort,
+          ) {
+            if $facts['is_virtual'] {
+              $_tinker = pick($tinker, true)
+            } else {
+              $tinker = pick($tinker, false)
+            }
+            Class['::ntp::install']
+            -> Class['::ntp::config']
+            ~> Class['::ntp::service']
+          }
+        CODE
+      end
+
+      it 'should detect no problem' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+    context 'on a complete code example with one bad array' do
+      let(:code) do
+        <<-CODE.gsub(/^ {10}/, '')
+          class testing(
+            Enum['present', 'absent'] $package_ensure,
+            Array[String] $keys,
+            Boolean $keys_enable,
+            Optional[Integer[0]] $panic,
+            Optional[Array[String]] $pool,
+            Variant[Boolean, Integer[0,1]] $tos_cohort,
+          ) {
+            if $facts['is_virtual'] {
+              $_tinker = pick($tinker, true)
+            } else {
+              $tinker = pick($tinker, false)
+            }
+            $keys_parameters = [$keys, $keys_enable]
+            Class['::ntp::install']
+            -> Class['::ntp::config']
+            ~> Class['::ntp::service']
+          }
+        CODE
+      end
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create fixes' do
+        expect(problems).to contain_fixed(msg).on_line(14).in_column(23)
+        expect(problems).to contain_fixed(msg).on_line(14).in_column(30)
+        expect(problems).to contain_fixed(msg_end).on_line(14).in_column(42)
+      end
+
+      it 'should properly format the manifest' do
+        expect(manifest).to eq(
+          <<-CODE.gsub(/^ {12}/, '')
+            class testing(
+              Enum['present', 'absent'] $package_ensure,
+              Array[String] $keys,
+              Boolean $keys_enable,
+              Optional[Integer[0]] $panic,
+              Optional[Array[String]] $pool,
+              Variant[Boolean, Integer[0,1]] $tos_cohort,
+            ) {
+              if $facts['is_virtual'] {
+                $_tinker = pick($tinker, true)
+              } else {
+                $tinker = pick($tinker, false)
+              }
+              $keys_parameters = [
+            $keys,
+            $keys_enable
+            ]
+              Class['::ntp::install']
+              -> Class['::ntp::config']
+              ~> Class['::ntp::service']
+            }
+          CODE
+        )
+      end
+    end
+  end
+end
+# rubocop:enable TrailingCommaInArguments