puppet-lint-class_alignment-check 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2a840e9e2d88d40af098ce22a8a2ca7d8dde090b727f85af6e05f72c84b79c95
+  data.tar.gz: be0f893935808ba8c07682dd5bd7457ca686ba8adc973a85a04d40d2785b656d
+SHA512:
+  metadata.gz: 4c312626c1d7b3b23584963c138b324ee11b5c1931c6f2bcf1f34a85a9aa95d99850c1fd31fb6ef96659d2646fa3bc4dfa40b516e102bc82944612bb0c5fcf39
+  data.tar.gz: 8cd001ccd8620fd4fd4f57ba946d36a23a2115d1ce2c2c0835e30c533f42cc064e426edcbaf87a42ce2d88c2d18ed8efc443bd8f91768fda2c7389329ba29696

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tim Sharpe
+
+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,41 @@
+# puppet-lint-class_alignment-check
+
+[![License](https://img.shields.io/github/license/anhpt379/puppet-lint-class_alignment-check.svg)](https://github.com/anhpt379/puppet-lint-class_alignment-check/blob/master/LICENSE)
+[![Test](https://github.com/anhpt379/puppet-lint-class_alignment-check/actions/workflows/test.yml/badge.svg)](https://github.com/anhpt379/puppet-lint-class_alignment-check/actions/workflows/test.yml)
+
+A puppet-lint plugin to check and fix class params/equals alignment.
+
+## Usage
+
+This plugin provides 2 checks for puppet-lint:
+
+- `class_params_alignment`
+- `class_equals_alignment`
+
+It supports `--fix` flag.
+
+> Parameters to classes or defined types must be uniformly indented in two
+> spaces from the title. The equals sign should be aligned.
+>
+> <https://puppet.com/docs/puppet/7/style_guide.html#style_guide_classes-param-indentation-alignment>
+
+```puppet
+class name (
+  $var1    = 'default',
+  $var2    = 'something else',
+  $another = 'another default value',
+) {
+
+}
+```
+
+```puppet
+class name (
+  Boolean                        $broadcastclient = false,
+  Optional[Stdlib::Absolutepath] $config_dir      = undef,
+  Enum['running', 'stopped']     $service_ensure  = 'running',
+  String                         $package_ensure  = 'present',
+) {
+
+}
+```

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

@@ -0,0 +1,213 @@
+# Parameters to classes or defined types must be uniformly indented in two
+# spaces from the title. The equals sign should be aligned.
+#
+# https://puppet.com/docs/puppet/7/style_guide.html#style_guide_classes-param-indentation-alignment
+
+require 'debug'
+
+def a_param?(token)
+  if token.prev_code_token.type == :EQUALS
+    false
+  elsif token.prev_code_token.type == :FARROW
+    false
+  elsif token.type == :VARIABLE && !%i[DQPRE DQMID].include?(token.prev_code_token.type)
+    true
+  end
+end
+
+def first_param_on_the_line?(token)
+  origin = token
+  while token&.prev_token
+    token = token.prev_token
+
+    break if token.type == :NEWLINE
+  end
+
+  while token&.next_token
+    token = token.next_token
+
+    break if token.type == :VARIABLE
+  end
+
+  origin == token
+end
+
+def the_one?(token, character)
+  case character
+  when '='
+    true if token.type == :EQUALS
+  when '$'
+    true if token.type == :VARIABLE && a_param?(token) && first_param_on_the_line?(token)
+  end
+end
+
+def get_the_first_param(token)
+  while token&.prev_code_token
+    token = token.prev_code_token
+    break if token.type == :CLASS
+  end
+
+  while token&.next_code_token
+    token = token.next_code_token
+    return token if token.type == :VARIABLE
+  end
+end
+
+def get_prev_code_token(token, character)
+  case character
+  when '='
+    token.prev_code_token
+  when '$'
+    if token.prev_code_token
+      if %i[CLASSREF RBRACK].include?(token.prev_code_token.type)
+        token.prev_code_token
+      elsif token.prev_code_token.type == :LPAREN
+        token
+      elsif token.prev_code_token.type == :COMMA
+        get_the_first_param(token)
+      end
+    end
+  end
+end
+
+# This function is copied & modified from puppet-lint arrow_alignment check
+# https://github.com/puppetlabs/puppet-lint/blob/020143b705b023946739eb44e7c7d99fcd087527/lib/puppet-lint/plugins/check_whitespace/arrow_alignment.rb#L8
+def check_for(character)
+  # I intentionally didn't rename `arrow` to another name, to keep the code as
+  # similar as the original one, to easier to update in the future.
+  (class_indexes + defined_type_indexes).each do |res_idx|
+    arrow_column = [0]
+    level_idx = 0
+    level_tokens = []
+    param_column = [nil]
+    resource_tokens = res_idx[:param_tokens]
+    next if resource_tokens.nil?
+
+    resource_tokens.reject! do |token|
+      COMMENT_TYPES.include?(token.type)
+    end
+
+    # If this is a single line resource, skip it
+    first_arrow = resource_tokens.index { |r| the_one?(r, character) }
+    last_arrow = resource_tokens.rindex { |r| the_one?(r, character) }
+    next if first_arrow.nil?
+    next if last_arrow.nil?
+    next if resource_tokens[first_arrow].line == resource_tokens[last_arrow].line
+
+    resource_tokens.each do |token|
+      if the_one?(token, character)
+        param_token = get_prev_code_token(token, character)
+        param_token = token if param_token.nil?
+
+        param_length = param_token.to_manifest.length
+
+        param_column[level_idx] = param_token.column if param_column[level_idx].nil?
+
+        if (level_tokens[level_idx] ||= []).any? { |t| t.line == token.line }
+          this_arrow_column = param_column[level_idx] + param_length + 1
+        elsif character == '$' && param_token.type == :VARIABLE
+          this_arrow_column = param_token.column
+        else
+          this_arrow_column = param_token.column + param_token.to_manifest.length
+          this_arrow_column += 1 if param_token.type != :INDENT
+        end
+
+        arrow_column[level_idx] = this_arrow_column if arrow_column[level_idx] < this_arrow_column
+
+        (level_tokens[level_idx] ||= []) << token
+      elsif token.prev_token.type == :LPAREN
+        level_idx += 1
+        arrow_column << 0
+        level_tokens[level_idx] ||= []
+        param_column << nil
+      elsif token.next_token.type == :RPAREN
+        if (level_tokens[level_idx] ||= []).map(&:line).uniq.length > 1
+          level_tokens[level_idx].each do |arrow_tok|
+            next if arrow_tok.column == arrow_column[level_idx] || level_tokens[level_idx].size == 1
+
+            arrows_on_line = level_tokens[level_idx].select { |t| t.line == arrow_tok.line }
+            notify(
+              :warning,
+              message: "indentation of #{character} is not properly aligned (expected in column #{arrow_column[level_idx]}, but found it in column #{arrow_tok.column})",
+              line: arrow_tok.line,
+              column: arrow_tok.column,
+              token: arrow_tok,
+              arrow_column: arrow_column[level_idx],
+              newline: arrows_on_line.index(arrow_tok) != 0,
+              newline_indent: param_column[level_idx] - 1
+            )
+          end
+        end
+        arrow_column[level_idx] = 0
+        level_tokens[level_idx].clear
+        param_column[level_idx] = nil
+        level_idx -= 1
+      end
+    end
+  end
+end
+
+# This function is copied & modified from puppet-lint arrow_alignment fix
+# https://github.com/puppetlabs/puppet-lint/blob/020143b705b023946739eb44e7c7d99fcd087527/lib/puppet-lint/plugins/check_whitespace/arrow_alignment.rb#L94
+def fix_for(problem)
+  if problem[:newline]
+    index = tokens.index(problem[:token].prev_code_token.prev_token)
+
+    # insert newline
+    tokens.insert(index, PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0))
+
+    # indent the parameter to the correct depth
+    problem[:token].prev_code_token.prev_token.type = :INDENT
+    problem[:token].prev_code_token.prev_token.value = ' ' * problem[:newline_indent]
+
+    end_param_idx = tokens.index(problem[:token].prev_code_token)
+    start_param_idx = tokens.index(problem[:token].prev_token_of(%i[INDENT NEWLINE]))
+    param_length = tokens[start_param_idx..end_param_idx].map do |r|
+                     r.to_manifest.length
+                   end.reduce(0) { |sum, x| sum + x } + 1
+    new_ws_len = problem[:arrow_column] - param_length
+  else
+    new_ws_len = if problem[:token].prev_token.type == :WHITESPACE
+                   problem[:token].prev_token.to_manifest.length
+                 else
+                   0
+                 end
+    new_ws_len += (problem[:arrow_column] - problem[:token].column)
+  end
+
+  if new_ws_len.negative?
+    raise PuppetLint::NoFix if problem[:token].prev_token.type != :INDENT
+
+    new_ws = problem[:token].prev_token.to_manifest[0...new_ws_len]
+    problem[:token].prev_token.value = new_ws
+  else
+    new_ws = ' ' * new_ws_len
+
+    if problem[:token].prev_token.type == :WHITESPACE
+      problem[:token].prev_token.value = new_ws
+    else
+      index = tokens.index(problem[:token].prev_token)
+      tokens.insert(index + 1, PuppetLint::Lexer::Token.new(:WHITESPACE, new_ws, 0, 0))
+    end
+  end
+end
+
+PuppetLint.new_check(:class_params_alignment) do
+  def check
+    check_for('$')
+  end
+
+  def fix(problem)
+    fix_for(problem)
+  end
+end
+
+PuppetLint.new_check(:class_equals_alignment) do
+  def check
+    check_for('=')
+  end
+
+  def fix(problem)
+    fix_for(problem)
+  end
+end

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

@@ -0,0 +1,483 @@
+require 'spec_helper'
+
+describe 'class_equals_alignment' do
+  let(:msg) { 'indentation of = is not properly aligned (expected in column %d, but found it in column %d)' }
+
+  context 'with fix disabled' do
+    context 'selectors inside a resource' do
+      let(:code) do
+        <<-END
+          class foo (
+            $ensure  = $ensure,
+            $require = $ensure ? {
+              present => Class['tomcat::install'],
+              absent  => undef;
+            },
+            $foo     = bar,
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'selectors in the middle of a resource' do
+      let(:code) do
+        <<-END
+          class foo (
+            $ensure = $ensure ? {
+              present => directory,
+              absent  => undef,
+            },
+            $owner  = 'tomcat6',
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'selector inside a resource' do
+      let(:code) do
+        <<-END
+          $ensure = $ensure ? {
+            present => directory,
+            absent  => undef,
+          },
+          $owner  = 'foo4',
+          $group  = 'foo4',
+          $mode   = '0755',
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'selector inside a hash inside a resource' do
+      let(:code) do
+        <<-END
+          $server = {
+            ensure => ensure => $ensure ? {
+              present => directory,
+              absent  => undef,
+            },
+            ip     => '192.168.1.1'
+          },
+          $owner  = 'foo4',
+          $group  = 'foo4',
+          $mode   = '0755',
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'nested hashes with correct indentation' do
+      let(:code) do
+        <<-END
+          class lvs::base (
+            $virtualeservers = {
+              '192.168.2.13' => {
+                vport        => '11025',
+                service      => 'smtp',
+                scheduler    => 'wlc',
+                protocol     => 'tcp',
+                checktype    => 'external',
+                checkcommand => '/path/to/checkscript',
+                real_servers => {
+                  'server01' => {
+                    real_server => '192.168.2.14',
+                    real_port   => '25',
+                    forwarding  => 'masq',
+                  },
+                  'server02' => {
+                    real_server => '192.168.2.15',
+                    real_port   => '25',
+                    forwarding  => 'masq',
+                  }
+                }
+              }
+            }
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'single resource with a misaligned =' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+            $bar = 2,
+            $gronk = 3,
+            $baz  = 4,
+            $meh = 5,
+          ) {}
+        END
+      end
+
+      it 'should detect four problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should create four warnings' do
+        expect(problems).to contain_warning(format(msg, 20, 18)).on_line(2).in_column(18)
+        expect(problems).to contain_warning(format(msg, 20, 18)).on_line(3).in_column(18)
+        expect(problems).to contain_warning(format(msg, 20, 19)).on_line(5).in_column(19)
+        expect(problems).to contain_warning(format(msg, 20, 18)).on_line(6).in_column(18)
+      end
+    end
+
+    context 'complex resource with a misaligned =' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+            $bar   = $baz ? {
+              gronk => 2,
+              meh => 3,
+            },
+            $meep = 4,
+            $bah= 5,
+          ) {}
+        END
+      end
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create three warnings' do
+        expect(problems).to contain_warning(format(msg, 19, 18)).on_line(2).in_column(18)
+        expect(problems).to contain_warning(format(msg, 19, 20)).on_line(3).in_column(20)
+        expect(problems).to contain_warning(format(msg, 19, 17)).on_line(8).in_column(17)
+      end
+    end
+
+    context 'resource with unaligned = in commented line' do
+      let(:code) do
+        <<-END
+          class foo (
+            $ensure = directory,
+            # $purge = true,
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'multiline resource with a single line of params' do
+      let(:code) do
+        <<-END
+          class mymodule::do_thing (
+            $whatever = 'bar', $one = 'two',
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'resource with aligned = too far out' do
+      let(:code) do
+        <<-END
+          class foo (
+            $ensure  = file,
+            $mode    = '0444',
+          ) {}
+        END
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create 2 warnings' do
+        expect(problems).to contain_warning(format(msg, 21, 22)).on_line(2).in_column(22)
+        expect(problems).to contain_warning(format(msg, 21, 22)).on_line(3).in_column(22)
+      end
+    end
+
+    context 'resource with multiple params where one is an empty hash' do
+      let(:code) do
+        <<-END
+          class foo (
+            $a = true,
+            $b = {
+            }
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'multiline resource with multiple params on a line' do
+      let(:code) do
+        <<-END
+          class test (
+            $a = 'foo', $bb = 'bar',
+            $ccc = 'baz',
+          ) {}
+        END
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create 2 warnings' do
+        expect(problems).to contain_warning(format(msg, 18, 16)).on_line(2).in_column(16)
+        expect(problems).to contain_warning(format(msg, 18, 29)).on_line(2).in_column(29)
+      end
+    end
+  end
+
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'single resource with a misaligned =' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+            $bar = 2,
+            $gronk = 3,
+            $baz  = 4,
+            $meh = 5,
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class foo (
+            $foo   = 1,
+            $bar   = 2,
+            $gronk = 3,
+            $baz   = 4,
+            $meh   = 5,
+          ) {}
+        END
+      end
+
+      it 'should detect four problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(format(msg, 20, 18)).on_line(2).in_column(18)
+        expect(problems).to contain_fixed(format(msg, 20, 18)).on_line(3).in_column(18)
+        expect(problems).to contain_fixed(format(msg, 20, 19)).on_line(5).in_column(19)
+        expect(problems).to contain_fixed(format(msg, 20, 18)).on_line(6).in_column(18)
+      end
+
+      it 'should align the class_paramss' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'complex resource with a misaligned =' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+            $bar  = $baz ? {
+              gronk => 2,
+              meh => 3,
+            },
+            $meep= 4,
+            $bah = 5,
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class foo (
+            $foo  = 1,
+            $bar  = $baz ? {
+              gronk => 2,
+              meh => 3,
+            },
+            $meep = 4,
+            $bah  = 5,
+          ) {}
+        END
+      end
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(format(msg, 19, 18)).on_line(2).in_column(18)
+        expect(problems).to contain_fixed(format(msg, 19, 18)).on_line(7).in_column(18)
+        expect(problems).to contain_fixed(format(msg, 19, 18)).on_line(8).in_column(18)
+      end
+
+      it 'should align the class_paramss' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'resource with aligned = too far out' do
+      let(:code) do
+        <<-END
+          class foo (
+            $ensure  = file,
+            $mode    = '0444',
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class foo (
+            $ensure = file,
+            $mode   = '0444',
+          ) {}
+        END
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create 2 warnings' do
+        expect(problems).to contain_fixed(format(msg, 21, 22)).on_line(2).in_column(22)
+        expect(problems).to contain_fixed(format(msg, 21, 22)).on_line(3).in_column(22)
+      end
+
+      it 'should realign the class_paramss with the minimum whitespace' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'resource with unaligned = and no whitespace between param and =' do
+      let(:code) do
+        <<-END
+          class test (
+            $param1 = 'foo',
+            $param2= 'bar',
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class test (
+            $param1 = 'foo',
+            $param2 = 'bar',
+          ) {}
+        END
+      end
+
+      it 'should detect 1 problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the problem' do
+        expect(problems).to contain_fixed(format(msg, 21, 20)).on_line(3).in_column(20)
+      end
+
+      it 'should add whitespace between the param and the class_params' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'multiline resource with multiple params on a line' do
+      let(:code) do
+        <<-END
+          class test (
+            $a = 'foo', $bb = 'bar',
+            $ccc = 'baz',
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class test (
+            $a   = 'foo',
+            $bb  = 'bar',
+            $ccc = 'baz',
+          ) {}
+        END
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should fix 2 problems' do
+        expect(problems).to contain_fixed(format(msg, 18, 16)).on_line(2).in_column(16)
+        expect(problems).to contain_fixed(format(msg, 18, 29)).on_line(2).in_column(29)
+      end
+
+      it 'should move the extra param onto its own line and realign' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'multiline resource with multiple params on a line, extra one longer' do
+      let(:code) do
+        <<-END
+          class test (
+            $a = 'foo', $bbccc = 'bar',
+            $ccc = 'baz',
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class test (
+            $a     = 'foo',
+            $bbccc = 'bar',
+            $ccc   = 'baz',
+          ) {}
+        END
+      end
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix 2 problems' do
+        expect(problems).to contain_fixed(format(msg, 20, 16)).on_line(2).in_column(16)
+        expect(problems).to contain_fixed(format(msg, 20, 32)).on_line(2).in_column(32)
+        expect(problems).to contain_fixed(format(msg, 20, 18)).on_line(3).in_column(18)
+      end
+
+      it 'should move the extra param onto its own line and realign' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,321 @@
+require 'spec_helper'
+
+describe 'class_params_alignment' do
+  let(:msg) { 'indentation of $ is not properly aligned (expected in column %d, but found it in column %d)' }
+
+  context 'with fix disabled' do
+    context 'with correct indentation' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo   = 1,
+            $bar   = 2,
+            $gronk = 3,
+            $baz   = 4,
+            $meh   = 5,
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'single resource with a misaligned $' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+          $bar = 2,
+          $gronk = 3,
+          $baz  = 4,
+           $meh = 5,
+          ) {}
+        END
+      end
+
+      it 'should detect four problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should create four warnings' do
+        expect(problems).to contain_warning(format(msg, 13, 11)).on_line(3).in_column(11)
+        expect(problems).to contain_warning(format(msg, 13, 11)).on_line(4).in_column(11)
+        expect(problems).to contain_warning(format(msg, 13, 11)).on_line(5).in_column(11)
+        expect(problems).to contain_warning(format(msg, 13, 12)).on_line(6).in_column(12)
+      end
+    end
+
+    context 'complex resource with a misaligned $' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+          $bar   = $baz ? {
+              gronk => 2,
+              meh => 3,
+            },
+              $meep = 4,
+                $bah= 5,
+          ) {}
+        END
+      end
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create three warnings' do
+        expect(problems).to contain_warning(format(msg, 13, 11)).on_line(3).in_column(11)
+        expect(problems).to contain_warning(format(msg, 13, 15)).on_line(7).in_column(15)
+        expect(problems).to contain_warning(format(msg, 13, 17)).on_line(8).in_column(17)
+      end
+    end
+
+    context 'resource with unaligned $ in commented line' do
+      let(:code) do
+        <<-END
+          class foo (
+            $ensure = directory,
+            # $purge = true,
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'multiline resource with a single line of params' do
+      let(:code) do
+        <<-END
+          class mymodule::do_thing (
+            $whatever = 'bar', $one = 'two',
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'resource with aligned $ too far out' do
+      let(:code) do
+        <<-END
+          class foo (
+                $ensure  = file,
+                $mode    = '0444',
+          ) {}
+        END
+      end
+
+      it 'should detect 0 problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'resource with multiple params where one is an empty hash' do
+      let(:code) do
+        <<-END
+          class foo (
+            $a = true,
+            $b = {
+            }
+          ) {}
+        END
+      end
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'multiline resource with multiple params on a line' do
+      let(:code) do
+        <<-END
+          class test (
+            $a = 'foo', $bb = 'bar',
+            $ccc = 'baz',
+          ) {}
+        END
+      end
+
+      it 'should detect 0 problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+  end
+
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'single resource with a misaligned $' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+              $bar = 2,
+              $gronk = 3,
+                $baz = 4,
+          $meh = 5,
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class foo (
+            $foo = 1,
+            $bar = 2,
+            $gronk = 3,
+            $baz = 4,
+            $meh = 5,
+          ) {}
+        END
+      end
+
+      it 'should detect four problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(format(msg, 13, 15)).on_line(3).in_column(15)
+        expect(problems).to contain_fixed(format(msg, 13, 15)).on_line(4).in_column(15)
+        expect(problems).to contain_fixed(format(msg, 13, 17)).on_line(5).in_column(17)
+        expect(problems).to contain_fixed(format(msg, 13, 11)).on_line(6).in_column(11)
+      end
+
+      it 'should align the class_paramss' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'complex resource with a misaligned =' do
+      let(:code) do
+        <<-END
+          class foo (
+            $foo = 1,
+          $bar = $baz ? {
+              gronk => $a,
+              meh => $b,
+            },
+          $meep= 4,
+          $bah = 5,
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class foo (
+            $foo = 1,
+            $bar = $baz ? {
+              gronk => $a,
+              meh => $b,
+            },
+            $meep= 4,
+            $bah = 5,
+          ) {}
+        END
+      end
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(format(msg, 13, 11)).on_line(3).in_column(11)
+        expect(problems).to contain_fixed(format(msg, 13, 11)).on_line(7).in_column(11)
+        expect(problems).to contain_fixed(format(msg, 13, 11)).on_line(8).in_column(11)
+      end
+
+      it 'should align the class_paramss' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'multiline resource with multiple params on a line' do
+      let(:code) do
+        <<-END
+          class test (
+            $a = 'foo', $bb = 'bar',
+          $ccc = 'baz',
+          ) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class test (
+            $a = 'foo', $bb = 'bar',
+            $ccc = 'baz',
+          ) {}
+        END
+      end
+
+      it 'should detect 1 problem' do
+        expect(problems).to have(1).problems
+      end
+
+      it 'should fix 1 problem' do
+        expect(problems).to contain_fixed(format(msg, 13, 11)).on_line(3).in_column(11)
+      end
+
+      it 'should move the extra param onto its own line and realign' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'multiline resource with inline variables' do
+      let(:code) do
+        <<-END
+          class name (
+            $aaa = function('foo', 'bar'),
+            $bbb = function('foo', 'bar'),
+            Boolean $key1 = false,
+            Enum['never', 'allow', 'try', 'demand'] $key2,
+          $materializer_version = $foo ? {
+              default => "foo ${bar} baz ${gronk} qux 0.4.1-1.el${::facts['operatingsystemmajrelease']}"
+          }) { }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class name (
+                                                    $aaa = function('foo', 'bar'),
+                                                    $bbb = function('foo', 'bar'),
+            Boolean                                 $key1 = false,
+            Enum['never', 'allow', 'try', 'demand'] $key2,
+                                                    $materializer_version = $foo ? {
+              default => "foo ${bar} baz ${gronk} qux 0.4.1-1.el${::facts['operatingsystemmajrelease']}"
+          }) { }
+        END
+      end
+
+      it 'should detect 4 problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should fix 4 problems' do
+        expect(problems).to contain_fixed(format(msg, 53, 13)).on_line(2).in_column(13)
+        expect(problems).to contain_fixed(format(msg, 53, 13)).on_line(3).in_column(13)
+        expect(problems).to contain_fixed(format(msg, 53, 21)).on_line(4).in_column(21)
+        expect(problems).to contain_fixed(format(msg, 53, 11)).on_line(6).in_column(11)
+      end
+
+      it 'should move the extra param onto its own line and realign' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'puppet-lint'
+
+PuppetLint::Plugins.load_spec_helper

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: puppet-lint-class_alignment-check
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anh Pham
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puppet-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "    A puppet-lint plugin to check & fix class params/equals alignment.\n"
+email: anhpt379@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/puppet-lint/plugins/check_class_params_alignment.rb
+- spec/puppet-lint/plugins/check_class_equals_alignment_spec.rb
+- spec/puppet-lint/plugins/check_class_params_alignment_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/anhpt379/puppet-lint-class_alignment-check
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A puppet-lint plugin to check & fix class params/equals alignment.
+test_files:
+- spec/puppet-lint/plugins/check_class_equals_alignment_spec.rb
+- spec/puppet-lint/plugins/check_class_params_alignment_spec.rb
+- spec/spec_helper.rb