puppet-lint-class_alignment-check 0.2.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebf0e96bee2765a17143585f49c445c388612b1563ac6ec54513ee39989013ef
-  data.tar.gz: 95d3539f4c25fd584610774c695394fb43b17ebb3881e0e73976f0a337eb6a57
+  metadata.gz: e32258dfb55db44ee2f3f0a2057958463c3c5ea2bad429c9bc5d179b772d6a71
+  data.tar.gz: 40ddced7d67f62decc65e9e9b396d2e60b19508aecf40039524c7c635d38fd0f
 SHA512:
-  metadata.gz: 374133ecbc4fa790491148cc2f62bbe630584891a10df2d3cffec9ce289b2b63ab8bdd6fcd43477735f25fe52e246535017af0f59d27b75f60bd9bf3714bff3c
-  data.tar.gz: d98666d602b2d846c5ad815d6f06b1dd15fa29ef7c896f6b507217d14e54f5536202aaef80127fc6b900b4ecd05b5183214641e55e45ae27a45dd7f28b0ba856
+  metadata.gz: 3e6caecc7f1607637a851670b86f258e2e4da20f9c39d900aeb971216ffdade15d5d3e35d3b31094376dae4e57c3b6e5c6aa97da875d340f4dc0a9d63b795229
+  data.tar.gz: 4fc0dd184ce132b65f032a55bd2146cdc11ee8abb7b9457ef5d8dc0e6cd4d242dc88440e0c293da1c726d61bf122a646ffbb3ad5ab478d035a6e37358d8cbfa8

data/README.md

@@ -11,13 +11,26 @@ A puppet-lint plugin to check and fix class params/equals alignment.
 
 ## Usage
 
-This plugin provides 2 checks for puppet-lint:
+This plugin provides 3 checks for puppet-lint:
 
+- `class_params_newline`
 - `class_params_alignment`
 - `class_equals_alignment`
 
 It supports `--fix` flag.
 
+To properly reformat the code, run `puppet-lint --fix` like this:
+
+```bash
+$ puppet-lint --only-checks class_params_newline --fix .
+$ puppet-lint --only-checks class_params_alignment --fix .
+$ puppet-lint --only-checks class_equals_alignment --fix .
+
+# It's best to combine the above checks with `strict_indent` to fix all remaining issues
+$ puppet-lint --only-checks strict_indent --fix .
+
+```
+
 > Parameters to classes or defined types must be uniformly indented in two
 > spaces from the title. The equals sign should be aligned.
 >

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

@@ -4,16 +4,16 @@
 # https://puppet.com/docs/puppet/7/style_guide.html#style_guide_classes-param-indentation-alignment
 
 def a_param?(token)
-  if token.prev_code_token.type == :EQUALS
+  if token&.prev_code_token&.type == :EQUALS
     false
-  elsif token.prev_code_token.type == :FARROW
+  elsif token&.prev_code_token&.type == :FARROW
     false
-  elsif token.type == :VARIABLE && !%i[DQPRE DQMID].include?(token.prev_code_token.type)
+  elsif token&.type == :VARIABLE && !%i[DQPRE DQMID].include?(token.prev_code_token.type)
     true
   end
 end
 
-def first_param_on_the_line?(token)
+def first_on_the_line?(token, type)
   origin = token
   while token&.prev_token
     token = token.prev_token
@@ -24,7 +24,7 @@ def first_param_on_the_line?(token)
   while token&.next_token
     token = token.next_token
 
-    break if token.type == :VARIABLE
+    break if token.type == type
   end
 
   origin == token
@@ -33,9 +33,9 @@ end
 def the_one?(token, character)
   case character
   when '='
-    true if token.type == :EQUALS
+    true if token.type == :EQUALS && first_on_the_line?(token, :EQUALS)
   when '$'
-    true if token.type == :VARIABLE && a_param?(token) && first_param_on_the_line?(token)
+    true if a_param?(token) && first_on_the_line?(token, :VARIABLE)
   end
 end
 
@@ -148,30 +148,14 @@ 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
+  raise PuppetLint::NoFix if problem[:newline]
+
+  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)
 
   if new_ws_len.negative?
     raise PuppetLint::NoFix if problem[:token].prev_token.type != :INDENT

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

@@ -0,0 +1,105 @@
+def prev_param_token(token)
+  while token&.prev_code_token
+    token = token.prev_code_token
+    break if a_param?(token)
+  end
+  token
+end
+
+PuppetLint.new_check(:class_params_newline) do
+  def check
+    (class_indexes + defined_type_indexes).each do |item|
+      tokens = item[:param_tokens]
+
+      first_param = tokens.index { |token| a_param?(token) }
+      last_param = tokens.rindex { |token| a_param?(token) }
+      next if first_param.nil?
+      next if last_param.nil?
+
+      # Skip if there's only 1 param
+      next if tokens[first_param] == tokens[last_param]
+
+      tokens.each do |token|
+        if token == tokens[-1]
+          rparen = token
+          while rparen&.next_token
+            rparen = rparen.next_token
+            break if rparen.type == :RPAREN
+          end
+
+          last_code_token = token
+          while last_code_token&.prev_token
+            break unless %i[WHITESPACE INDENT NEWLINE].include?(last_code_token.type)
+
+            last_code_token = last_code_token.prev_token
+          end
+
+          next if rparen.line != last_code_token.line
+
+          notify(
+            :warning,
+            message: "`)` should be in a new line (expected in line #{token.line + 1}, but found it in line #{token.line})",
+            line: rparen.line,
+            column: rparen.column,
+            token: rparen,
+            newline: true,
+            newline_indent: item[:tokens][0].column - 1
+          )
+          break
+        end
+
+        next unless a_param?(token)
+
+        if token.prev_code_token.type == :LPAREN
+          next if token.line != token.prev_code_token.line
+        elsif token.line != prev_param_token(token).line
+          next
+        end
+
+        notify(
+          :warning,
+          message: "`#{token.to_manifest}` should be in a new line (expected in line #{token.line + 1}, but found it in line #{token.line})",
+          line: token.line,
+          column: token.column,
+          token: token,
+          newline: true,
+          newline_indent: item[:tokens][0].column + 1
+        )
+      end
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    case token&.prev_code_token&.type
+    when :TYPE
+      token = token.prev_code_token
+    when :RBRACK
+      count = 0
+      while token&.prev_code_token
+        token = token.prev_code_token
+        case token.type
+        when :RBRACK
+          count += 1
+        when :LBRACK
+          count -= 1
+        end
+
+        break if count.zero?
+      end
+      token = token.prev_code_token
+    end
+
+    index = tokens.index(token.prev_code_token.next_token)
+    tokens.insert(index, PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0))
+
+    # When there's no space at the beginning of the param
+    # e.g.  class foo($bar="aaa") {}
+    if token.prev_code_token.next_token == token
+      tokens.insert(index + 1, PuppetLint::Lexer::Token.new(:INDENT, ' ' * problem[:newline_indent], 0, 0))
+
+    elsif %i[WHITESPACE INDENT].include?(token.prev_token.type)
+      token.prev_token.value = ' ' * problem[:newline_indent]
+    end
+  end
+end

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

@@ -241,13 +241,12 @@ describe 'class_equals_alignment' do
         END
       end
 
-      it 'should detect 2 problems' do
-        expect(problems).to have(2).problems
+      it 'should detect 1 problem' do
+        expect(problems).to have(1).problems
       end
 
-      it 'should create 2 warnings' do
+      it 'should create 1 warning' 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
@@ -424,23 +423,21 @@ describe 'class_equals_alignment' do
       let(:fixed) do
         <<-END
           class test (
-            $a   = 'foo',
-            $bb  = 'bar',
+            $a   = 'foo', $bb = 'bar',
             $ccc = 'baz',
           ) {}
         END
       end
 
-      it 'should detect 2 problems' do
-        expect(problems).to have(2).problems
+      it 'should detect 1 problem' do
+        expect(problems).to have(1).problems
       end
 
-      it 'should fix 2 problems' do
+      it 'should fix 1 problem' 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
+      it 'should not move the extra param onto its own line and realign' do
         expect(manifest).to eq(fixed)
       end
     end
@@ -458,24 +455,21 @@ describe 'class_equals_alignment' do
       let(:fixed) do
         <<-END
           class test (
-            $a     = 'foo',
-            $bbccc = 'bar',
-            $ccc   = 'baz',
+            $a   = 'foo', $bbccc = 'bar',
+            $ccc = 'baz',
           ) {}
         END
       end
 
-      it 'should detect 2 problems' do
-        expect(problems).to have(3).problems
+      it 'should detect 1 problem' do
+        expect(problems).to have(1).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)
+      it 'should fix 1 problem' do
+        expect(problems).to contain_fixed(format(msg, 18, 16)).on_line(2).in_column(16)
       end
 
-      it 'should move the extra param onto its own line and realign' do
+      it 'should not move the extra param onto its own line and realign' do
         expect(manifest).to eq(fixed)
       end
     end

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

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe 'class_params_newline' do
+  let(:msg) { '`%s` should be in a new line (expected in line %d, but found it in line %d)' }
+
+  context 'with fix disabled' do
+    context 'tidy code' do
+      let(:code) do
+        <<-END
+          class bar(
+                                                        $someparam = 'somevalue',
+                                                        $another,
+            String                                      $nope,
+                                                        $foo,
+            Variant[Undef, Enum['UNSET'], Stdlib::Port] $db_port,
+            # $aaa,
+            String                                      $third     = 'meh',
+            Array[Int, Int]                             $asdf      = 'asdf',
+          ) { }
+        END
+      end
+
+      it 'should detect 0 problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'messy code' do
+      let(:code) do
+        <<-END
+          class bar(                                                        $someparam = 'somevalue',
+            $another, String $nope, $foo,
+            Variant[Undef, Enum['UNSET'], Stdlib::Port] $db_port,
+            # $aaa,
+            String                                              $third     = 'meh', Array[Int, Int] $asdf = 'asdf',
+          ) { }
+        END
+      end
+
+      it 'should detect 4 problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should create four warnings' do
+        expect(problems).to contain_warning(format(msg, '$someparam', 2, 1)).on_line(1).in_column(77)
+        expect(problems).to contain_warning(format(msg, '$nope', 3, 2)).on_line(2).in_column(30)
+        expect(problems).to contain_warning(format(msg, '$foo', 3, 2)).on_line(2).in_column(37)
+        expect(problems).to contain_warning(format(msg, '$asdf', 6, 5)).on_line(5).in_column(101)
+      end
+    end
+  end
+
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'messy code' do
+      let(:code) do
+        <<-END
+          class bar(                                                        $someparam = 'somevalue',
+            $another, String $nope, $foo,
+            Variant[Undef, Enum['UNSET'], Stdlib::Port] $db_port,
+            # $aaa,
+            String                                              $third     = 'meh', Array[Int, Int] $asdf = 'asdf',
+          ) { }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class bar(
+            $someparam = 'somevalue',
+            $another,
+            String $nope,
+            $foo,
+            Variant[Undef, Enum['UNSET'], Stdlib::Port] $db_port,
+            # $aaa,
+            String                                              $third     = 'meh',
+            Array[Int, Int] $asdf = 'asdf',
+          ) { }
+        END
+      end
+
+      it 'should fix the problems' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'in a single line' do
+      let(:code) do
+        <<-END
+          class foo ($foo = 1, $bar = $a) {}
+
+          class bar ($foo = 1, $bar = $a,) {}
+
+          class aaa ( $foo = 1, $bar = $a,) {}
+
+          class bbb ( $foo = 1, $bar = $a, ) {}
+
+          class ccc ($foo = 1) {}
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          class foo (
+            $foo = 1,
+            $bar = $a
+          ) {}
+
+          class bar (
+            $foo = 1,
+            $bar = $a,
+          ) {}
+
+          class aaa (
+            $foo = 1,
+            $bar = $a,
+          ) {}
+
+          class bbb (
+            $foo = 1,
+            $bar = $a,
+          ) {}
+
+          class ccc ($foo = 1) {}
+        END
+      end
+
+      it 'should fix the problems' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-lint-class_alignment-check
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.1
 platform: ruby
 authors:
 - Anh Pham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-08 00:00:00.000000000 Z
+date: 2022-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet-lint
@@ -123,8 +123,10 @@ files:
 - LICENSE
 - README.md
 - lib/puppet-lint/plugins/check_class_alignment.rb
+- lib/puppet-lint/plugins/check_class_params_newline.rb
 - spec/puppet-lint/plugins/check_class_equals_alignment_spec.rb
 - spec/puppet-lint/plugins/check_class_params_alignment_spec.rb
+- spec/puppet-lint/plugins/check_class_params_newline_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/anhpt379/puppet-lint-class_alignment-check
 licenses:
@@ -152,4 +154,5 @@ 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/puppet-lint/plugins/check_class_params_newline_spec.rb
 - spec/spec_helper.rb