puppet-lint-manifest_whitespace-check 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6c95fdd92713473387e0cb780ba993b73aac14c1b8a31ac3605cb211cb34413
-  data.tar.gz: 51b93e74f8b2ce71082873f4023efabc673fd8a6144710341695efdc80c102cc
+  metadata.gz: 82fd48a0b533bc6357b7e250f945f8ab3f0ba80625a19fa060fde543bf854dae
+  data.tar.gz: 5289f75f1e16b08fb0b18c6798326017625d6a9b71cb061e9f020e4267630a45
 SHA512:
-  metadata.gz: 1940d7236fab0350b6cf217c41a88228f50de795f8e68ca3b3d0da03289578fc83ffc4708c86d37ffd71f9c8b0b254be75121c6c311e43aef7d4acfc89950170
-  data.tar.gz: e5cb33fa8ee74bb757fcab7cb333090b3e9770e909274ce313a51e5e1a382c60799893235f8a40d31fac1b21cf9c39b6ba4479765f75bd92e0a2563dc9e47bf9
+  metadata.gz: 4ff960cc339885dfbfa62823058381bb609ca8de39f1047837f2882efb325e176251dcec6f9786907b5fa14145e4f8ad0dfea52e942eadc6909ebc1f8f8f3dd1
+  data.tar.gz: 9a4f2cd1929e5ca731efb25894730e0ec793d4f2ebc9f3a46baa045deb9d6891e092402afe42acdd8cb83e6cfa808d7033fdb515d60360a4be1a7452e83f54dd

data/README.md

@@ -19,9 +19,17 @@ gem 'puppet-lint-manifest_whitespace-check'
 
 This plugin provides a number of new checks to `puppet-lint`.
 
-### manifest_whitespace_class_opening_curly_brace
+### manifest_whitespace_opening_bracket_after
 
-> There should be a single space before the opening curly brace of a class body.
+> There should be a single space or single newline after an opening curly brace
+
+Exceptions: other brackets or comma's
+
+### manifest_whitespace_opening_bracket_before
+
+> There should be a single space before an opening bracket
+
+Exceptions: other brackets
 
 Good examples:
 
@@ -35,6 +43,14 @@ class myclass (
 class myclass {
   # the body
 }
+
+class myclass {
+  $value = [{ 'key' => 'value' }]
+
+  if somecondition {
+    class { 'someclass': }
+  }
+}
 ```
 
 Bad examples:
@@ -57,6 +73,12 @@ class myclass
 {
   # the body
 }
+
+class myclass {
+  if somecondition{
+    class{ 'someclass': }
+  }
+}
 ```
 
 ### manifest_whitespace_missing_newline_end_of_file

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

@@ -26,46 +26,3 @@ PuppetLint.new_check(:manifest_whitespace_inherits_name_single_space_before) do
     problem[:token].value = ' '
   end
 end
-
-PuppetLint.new_check(:manifest_whitespace_inherits_name_single_space_after) do
-  def check
-    tokens.select { |token| token.type == :INHERITS }.each do |inherits_token|
-      name_token = inherits_token.next_token_of(%i[NAME FUNCTION_NAME])
-      next unless name_token
-
-      next_token = name_token.next_token
-      brace_token = name_token.next_token_of(%i[LPAREN LBRACE])
-      next unless tokens.index(name_token) != tokens.index(brace_token) - 2 ||
-                  !is_single_space(next_token)
-
-      notify(
-        :error,
-        message: 'there should be a single space between the class or resource name and the first brace',
-        line: next_token.line,
-        column: next_token.column,
-        token: next_token,
-      )
-    end
-  end
-
-  def fix(problem)
-    token = problem[:token]
-    brace_token = token.prev_token.next_token_of(%i[LPAREN LBRACE])
-
-    if token == brace_token
-      add_token(tokens.index(brace_token), new_single_space)
-      return
-    end
-
-    while token != brace_token
-      unless %i[WHITESPACE INDENT NEWLINE].include?(token.type)
-        raise PuppetLint::NoFix
-      end
-
-      remove_token(token)
-      token = token.next_token
-    end
-
-    add_token(tokens.index(brace_token), new_single_space)
-  end
-end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_closing_brace_before) do
+  def check
+    tokens.select { |token| token.type == :RBRACE }.each do |brace_token|
+      prev_token = brace_token.prev_token
+      prev_code_token = brace_token.prev_code_token
+
+      next unless prev_token && prev_code_token
+      next if %i[LBRACE RBRACK RBRACE].include?(prev_token.type)
+
+      unless %i[LBRACE RBRACK RBRACE].include?(prev_code_token.type)
+        if is_single_space(prev_token) && tokens.index(prev_code_token) == tokens.index(brace_token) - 2
+          next
+        end
+      end
+
+      if prev_token.type == :INDENT
+        next if tokens.index(prev_code_token) == tokens.index(brace_token) - 3
+      end
+
+      if prev_token.type == :NEWLINE
+        next if tokens.index(prev_code_token) == tokens.index(brace_token) - 2
+      end
+
+      notify(
+        :error,
+        message: 'there should be a bracket or a single newline before a closing brace',
+        line: prev_code_token.next_token.line,
+        column: prev_code_token.next_token.column,
+        token: prev_code_token.next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+
+    next_token = token
+
+    until next_token.type == :RBRACE
+      if tokens[tokens.index(next_token)..-1].first(2).collect(&:type) == %i[NEWLINE RBRACE]
+        break
+      end
+
+      if tokens[tokens.index(next_token)..-1].first(3).collect(&:type) == %i[NEWLINE INDENT RBRACE]
+        break
+      end
+
+      remove_token(next_token)
+      next_token = next_token.next_token
+    end
+
+    if next_token.type == :RBRACE && !%i[LBRACE RBRACE RBRACK NEWLINE INDENT].include?(next_token.prev_token.type)
+      add_token(tokens.index(next_token), new_single_space)
+    end
+  end
+end
+
+PuppetLint.new_check(:manifest_whitespace_closing_brace_after) do
+  def check
+    tokens.select { |token| token.type == :RBRACE }.each do |brace_token|
+      next_token = brace_token.next_token
+
+      next unless next_token
+      next if after_bracket_tokens.include?(next_token.type)
+
+      if next_token.type == :WHITESPACE
+        next_code_token = brace_token.next_code_token
+        next unless next_code_token
+        next unless after_bracket_tokens.include?(next_code_token.type)
+      end
+
+      notify(
+        :error,
+        message: 'there should be either a bracket, comma, colon, closing quote or a newline after a closing brace, or whitespace and none of the aforementioned',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+
+    next_token = token
+
+    until %i[RBRACE RBRACK RPAREN COMMA NEWLINE].include?(next_token.type)
+      raise PuppetLint::NoFix if next_token.type != :WHITESPACE
+
+      remove_token(next_token)
+      next_token = next_token.next_token
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_closing_bracket_before) do
+  def check
+    tokens.select { |token| token.type == :RBRACK }.each do |bracket_token|
+      prev_token = bracket_token.prev_token
+      next unless prev_token
+
+      prev_code_token = bracket_token.prev_code_token
+      next unless prev_code_token
+
+      next unless %i[NEWLINE INDENT WHITESPACE].include?(prev_token.type)
+
+      if prev_token.type == :INDENT
+        next if tokens.index(prev_code_token) == tokens.index(bracket_token) - 3
+      end
+      if prev_token.type == :NEWLINE
+        next if tokens.index(prev_code_token) == tokens.index(bracket_token) - 2
+      end
+
+      notify(
+        :error,
+        message: 'there should be no whitespace or a single newline before a closing bracket',
+        line: prev_code_token.next_token.line,
+        column: prev_code_token.next_token.column,
+        token: prev_code_token.next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    if token.type == :WHITESPACE
+      remove_token(token)
+      return
+    end
+
+    next_token = token.next_token
+    until next_token.type == :RBRACK
+      if next_token.type == :INDENT && next_token.next_token.type == :RBRACK
+        break
+      end
+
+      remove_token(next_token)
+      next_token = next_token.next_token
+    end
+  end
+end
+
+PuppetLint.new_check(:manifest_whitespace_closing_bracket_after) do
+  def check
+    tokens.select { |token| token.type == :RBRACK }.each do |bracket_token|
+      next_token = bracket_token.next_token
+
+      next unless next_token
+      next if after_bracket_tokens.include?(next_token.type)
+
+      if next_token.type == :WHITESPACE
+        next_code_token = bracket_token.next_code_token
+        next unless next_code_token
+        next unless after_bracket_tokens.include?(next_code_token.type)
+      end
+
+      notify(
+        :error,
+        message: 'there should be either a bracket, comma, colon, closing quote or a newline after a closing bracket, or whitespace and none of the aforementioned',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+
+    next_token = token
+
+    until %i[RBRACE RBRACK RPAREN COMMA NEWLINE].include?(next_token.type)
+      raise PuppetLint::NoFix if next_token.type != :WHITESPACE
+
+      remove_token(next_token)
+      next_token = next_token.next_token
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_opening_brace_before) do
+  def check
+    tokens.select { |token| token.type == :LBRACE }.each do |brace_token|
+      prev_token = brace_token.prev_token
+      prev_code_token = brace_token.prev_code_token
+
+      next unless prev_token && prev_code_token
+      next if %i[LBRACK LBRACE COMMA].include?(prev_code_token.type)
+      next unless tokens.index(prev_code_token) != tokens.index(brace_token) - 2 ||
+                  !is_single_space(prev_token)
+
+      notify(
+        :error,
+        message: 'there should be a single space before an opening brace',
+        line: brace_token.line,
+        column: brace_token.column,
+        token: brace_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    prev_token = token.prev_token
+    prev_code_token = token.prev_code_token
+
+    while prev_code_token != prev_token
+      unless %i[WHITESPACE INDENT NEWLINE].include?(prev_token.type)
+        raise PuppetLint::NoFix
+      end
+
+      remove_token(prev_token)
+      prev_token = prev_token.prev_token
+    end
+
+    add_token(tokens.index(token), new_single_space)
+  end
+end
+
+PuppetLint.new_check(:manifest_whitespace_opening_brace_after) do
+  def check
+    tokens.select { |token| token.type == :LBRACE }.each do |brace_token|
+      next_token = brace_token.next_token
+
+      next unless next_token && !is_single_space(next_token)
+      next if %i[LBRACK LBRACE RBRACE].include?(next_token.type)
+
+      if next_token.type == :NEWLINE
+        next_token = next_token.next_token
+        next if next_token.type != :NEWLINE
+      end
+
+      notify(
+        :error,
+        message: 'there should be a single space or single newline after an opening brace',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+
+    if token.type == :WHITESPACE
+      token.value = ' '
+      return
+    end
+
+    if token.type == :NEWLINE
+      while token && token.type == :NEWLINE
+        remove_token(token)
+        token = token.next_token
+      end
+      return
+    end
+
+    add_token(tokens.index(token), new_single_space)
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_opening_bracket_before) do
+  def check
+    tokens.select { |token| token.type == :LBRACK }.each do |bracket_token|
+      prev_token = bracket_token.prev_token
+      prev_code_token = bracket_token.prev_code_token
+
+      next unless prev_token && prev_code_token
+      next if %i[LBRACK LBRACE COMMA SEMIC].include?(prev_code_token.type)
+      next unless %i[WHITESPACE NEWLINE INDENT].include?(prev_token.type)
+      next unless tokens.index(prev_code_token) != tokens.index(bracket_token) - 2 ||
+                  !is_single_space(prev_token)
+
+      notify(
+        :error,
+        message: 'there should be a single space before an opening bracket',
+        line: bracket_token.line,
+        column: bracket_token.column,
+        token: bracket_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    prev_token = token.prev_token
+    prev_code_token = token.prev_code_token
+
+    while prev_code_token != prev_token
+      unless %i[WHITESPACE INDENT NEWLINE].include?(prev_token.type)
+        raise PuppetLint::NoFix
+      end
+
+      remove_token(prev_token)
+      prev_token = prev_token.prev_token
+    end
+
+    add_token(tokens.index(token), new_single_space)
+  end
+end
+
+PuppetLint.new_check(:manifest_whitespace_opening_bracket_after) do
+  def check
+    tokens.select { |token| token.type == :LBRACK }.each do |bracket_token|
+      next_token = bracket_token.next_token
+
+      next unless next_token
+      next unless %i[WHITESPACE NEWLINE INDENT].include?(next_token.type)
+
+      if next_token.type == :NEWLINE
+        next_token = next_token.next_token
+        next if next_token.type != :NEWLINE
+      end
+
+      notify(
+        :error,
+        message: 'there should be no whitespace or a single newline after an opening bracket',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+
+    if token.type == :WHITESPACE
+      remove_token(token)
+      return
+    end
+
+    while token.next_token.type == :NEWLINE || (token.next_token.type == :INDENT && token.next_token.next_token.type != :NEWLINE)
+      remove_token(token)
+      token = token.next_token
+    end
+  end
+end