puppet-lint-manifest_whitespace-check 0.0.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3d91ac8fb2a3196f56aa2e30c76acdfa62f1b318
-  data.tar.gz: a8a98d0f46aada6c955650901e3fe9cdec2b565d
+SHA256:
+  metadata.gz: 8c2f9e366e644a2d8e44d200454971dbd137c8f5584a874a8b90778115066ef0
+  data.tar.gz: af0b459243c84ff834246bbb00b96cb72fb6f24cc4636496d2e7b9d22fa51e84
 SHA512:
-  metadata.gz: f1bd0c7f396ce8307204b2fbb4b843cf570fecc32181a0c1ddf6095f60642f3518a072508d496d5b3af9fd84581180340736b1f212e41be3b64d3d9253807d1d
-  data.tar.gz: d3484a2404a91a7d558a1a8fb57c95e42f26abd43a8db0d5ba98cb6bdaefea39048b353cdf269dac72df4eeaca873759775117548d52c65c9c48088042798dcb
+  metadata.gz: 24eb7bec7bc98a193b0c34e690723703f34b37903e5aadb3dd38a0b803dc743320a86f8f0312af44e7ebda6ec0c69847e16cd812fb3ec8e87319fce7c59a2d4d
+  data.tar.gz: a8b40c6b1a020f1b70f1b7c75512a61f6514403efcaad9cd58abbf8fa0b515b73381d527cb1f2f7ee06b32c74266b7c81a7dc1e3c0939882b5aae4d60a3293fe

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 bracket 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
@@ -113,7 +135,7 @@ class  myclass (
 
 ### manifest_whitespace_class_name_single_space_after
 
-> There should be a single space between the class or resource name and the first bracket.
+> There should be a single space between the class or resource name and the first brace.
 
 Good examples:
 

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_inherits_name_single_space_before) 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 = inherits_token.next_token
+      next unless tokens.index(name_token) != tokens.index(inherits_token) + 2 ||
+                  !is_single_space(next_token)
+
+      notify(
+        :error,
+        message: 'there should be a single space between the inherits statement and the name',
+        line: next_token.line,
+        column: next_token.column,
+        token: next_token,
+      )
+    end
+  end
+
+  def fix(problem)
+    raise PuppetLint::NoFix if problem[:token].type != :WHITESPACE
+
+    problem[:token].value = ' '
+  end
+end

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

@@ -4,7 +4,7 @@ PuppetLint.new_check(:manifest_whitespace_class_name_single_space_before) do
   def check
     (class_indexes + defined_type_indexes).each do |class_idx|
       class_token = class_idx[:tokens].first
-      name_token = class_token.next_token_of(:NAME)
+      name_token = class_token.next_token_of(%i[NAME FUNCTION_NAME])
       next unless name_token
 
       next_token = class_token.next_token
@@ -32,17 +32,17 @@ PuppetLint.new_check(:manifest_whitespace_class_name_single_space_after) do
   def check
     (class_indexes + defined_type_indexes).each do |class_idx|
       class_token = class_idx[:tokens].first
-      name_token = class_token.next_token_of(:NAME)
+      name_token = class_token.next_token_of(%i[NAME FUNCTION_NAME])
       next unless name_token
 
       next_token = name_token.next_token
-      bracket_token = name_token.next_token_of(%i[LPAREN LBRACE])
-      next unless tokens.index(name_token) != tokens.index(bracket_token) - 2 ||
+      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 bracket',
+        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,
@@ -52,14 +52,14 @@ PuppetLint.new_check(:manifest_whitespace_class_name_single_space_after) do
 
   def fix(problem)
     token = problem[:token]
-    bracket_token = token.prev_token.next_token_of(%i[LPAREN LBRACE])
+    brace_token = token.prev_token.next_token_of(%i[LPAREN LBRACE])
 
-    if token == bracket_token
-      add_token(tokens.index(bracket_token), new_single_space)
+    if token == brace_token
+      add_token(tokens.index(brace_token), new_single_space)
       return
     end
 
-    while token != bracket_token
+    while token != brace_token
       unless %i[WHITESPACE INDENT NEWLINE].include?(token.type)
         raise PuppetLint::NoFix
       end
@@ -68,6 +68,6 @@ PuppetLint.new_check(:manifest_whitespace_class_name_single_space_after) do
       token = token.next_token
     end
 
-    add_token(tokens.index(bracket_token), new_single_space)
+    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 = prev_non_space_token(brace_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 = next_non_space_token(brace_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 = prev_non_space_token(bracket_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 = next_non_space_token(bracket_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_empty_lines.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+PuppetLint.new_check(:manifest_whitespace_two_empty_lines) do
+  def check
+    tokens.select { |token| token.type == :NEWLINE }.each do |token|
+      prev_newline = token.prev_token_of(:NEWLINE)
+      next unless prev_newline
+
+      prev_newline = prev_newline.prev_token_of(:NEWLINE)
+      next unless prev_newline
+
+      good_to_go = true
+      tokens.index(prev_newline).upto(tokens.index(token)).each do |between_token_idx|
+        unless %i[NEWLINE WHITESPACE INDENT].include?(tokens[between_token_idx].type)
+          good_to_go = false
+          break
+        end
+      end
+      next unless good_to_go
+
+      notify(
+        :error,
+        message: 'there should be no two consecutive empty lines',
+        line: token.line,
+        column: token.column,
+        token: token,
+      )
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    remove_token(token)
+  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 = prev_non_space_token(brace_token)
+
+      next unless prev_token && prev_code_token
+      next if %i[LBRACK LBRACE COMMA COMMENT].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 = prev_non_space_token(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