puppet-lint 2.2.1 → 2.3.0

data/lib/puppet-lint/plugins/check_comments/slash_comments.rb

@@ -0,0 +1,22 @@
+# Public: Check the manifest tokens for any comments started with slashes
+# (//) and record a warning for each instance found.
+#
+# https://docs.puppet.com/guides/style_guide.html#comments
+PuppetLint.new_check(:slash_comments) do
+  def check
+    tokens.select { |token|
+      token.type == :SLASH_COMMENT
+    }.each do |token|
+      notify :warning, {
+        :message => '// comment found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      }
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = :COMMENT
+  end
+end

data/lib/puppet-lint/plugins/{check_comments.rb → check_comments/star_comments.rb}

@@ -1,26 +1,3 @@
-# Public: Check the manifest tokens for any comments started with slashes
-# (//) and record a warning for each instance found.
-#
-# https://docs.puppet.com/guides/style_guide.html#comments
-PuppetLint.new_check(:slash_comments) do
-  def check
-    tokens.select { |token|
-      token.type == :SLASH_COMMENT
-    }.each do |token|
-      notify :warning, {
-        :message => '// comment found',
-        :line    => token.line,
-        :column  => token.column,
-        :token   => token,
-      }
-    end
-  end
-
-  def fix(problem)
-    problem[:token].type = :COMMENT
-  end
-end
-
 # Public: Check the manifest tokens for any comments encapsulated with
 # slash-asterisks (/* */) and record a warning for each instance found.
 #
@@ -41,7 +18,7 @@ PuppetLint.new_check(:star_comments) do
 
   def fix(problem)
     comment_lines = problem[:token].value.strip.split("\n").map(&:strip)
-    
+
     first_line = comment_lines.shift
     problem[:token].type = :COMMENT
     problem[:token].value = " #{first_line}"

data/lib/puppet-lint/plugins/{check_conditionals.rb → check_conditionals/case_without_default.rb}

@@ -1,29 +1,3 @@
-# Public: Test the manifest tokens for any selectors embedded within resource
-# declarations and record a warning for each instance found.
-#
-# https://docs.puppet.com/guides/style_guide.html#keep-resource-declarations-simple
-PuppetLint.new_check(:selector_inside_resource) do
-  def check
-    resource_indexes.each do |resource|
-      resource[:tokens].each do |token|
-        if token.type == :FARROW
-          if token.next_code_token.type == :VARIABLE
-            unless token.next_code_token.next_code_token.nil?
-              if token.next_code_token.next_code_token.type == :QMARK
-                notify :warning, {
-                  :message => 'selector inside resource block',
-                  :line    => token.line,
-                  :column  => token.column,
-                }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
 # Public: Test the manifest tokens for any case statements that do not
 # contain a "default" case and record a warning for each instance found.
 #
@@ -54,7 +28,7 @@ PuppetLint.new_check(:case_without_default) do
       case_tokens = tokens[kase[:start]..kase[:end]]
 
       case_indexes[(kase_index + 1)..-1].each do |successor_kase|
-	case_tokens -= tokens[successor_kase[:start]..successor_kase[:end]]
+        case_tokens -= tokens[successor_kase[:start]..successor_kase[:end]]
       end
 
       unless case_tokens.index { |r| r.type == :DEFAULT }

data/lib/puppet-lint/plugins/check_conditionals/selector_inside_resource.rb

@@ -0,0 +1,25 @@
+# Public: Test the manifest tokens for any selectors embedded within resource
+# declarations and record a warning for each instance found.
+#
+# https://docs.puppet.com/guides/style_guide.html#keep-resource-declarations-simple
+PuppetLint.new_check(:selector_inside_resource) do
+  def check
+    resource_indexes.each do |resource|
+      resource[:tokens].each do |token|
+        if token.type == :FARROW
+          if token.next_code_token.type == :VARIABLE
+            unless token.next_code_token.next_code_token.nil?
+              if token.next_code_token.next_code_token.type == :QMARK
+                notify :warning, {
+                  :message => 'selector inside resource block',
+                  :line    => token.line,
+                  :column  => token.column,
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet-lint/plugins/check_resources/duplicate_params.rb

@@ -0,0 +1,37 @@
+# Public: Check the tokens of each resource instance for any duplicate
+# parameters and record a warning for each instance found.
+#
+# No style guide reference
+PuppetLint.new_check(:duplicate_params) do
+  def check
+    resource_indexes.each do |resource|
+      seen_params = {}
+      level = 0
+
+      resource[:tokens].each_with_index do |token, idx|
+        case token.type
+        when :LBRACE
+          level += 1
+          next
+        when :RBRACE
+          seen_params.delete(level)
+          level -= 1
+          next
+        when :FARROW
+          prev_token = token.prev_code_token
+          next unless prev_token.type == :NAME
+
+          if (seen_params[level] ||= Set.new).include?(prev_token.value)
+            notify :error, {
+              :message => 'duplicate parameter found in resource',
+              :line    => prev_token.line,
+              :column  => prev_token.column,
+            }
+          else
+            seen_params[level] << prev_token.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet-lint/plugins/check_resources/ensure_first_param.rb

@@ -0,0 +1,70 @@
+# Public: Check the tokens of each resource instance for an ensure parameter
+# and if found, check that it is the first parameter listed.  If it is not
+# the first parameter, record a warning.
+#
+# https://docs.puppet.com/guides/style_guide.html#attribute-ordering
+PuppetLint.new_check(:ensure_first_param) do
+  def check
+    resource_indexes.each do |resource|
+      next if [:CLASS].include? resource[:type].type
+      ensure_attr_index = resource[:param_tokens].index { |param_token|
+        param_token.value == 'ensure'
+      }
+
+      unless ensure_attr_index.nil?
+        if ensure_attr_index > 0
+          ensure_token = resource[:param_tokens][ensure_attr_index]
+          notify :warning, {
+            :message  => "ensure found on line but it's not the first attribute",
+            :line     => ensure_token.line,
+            :column   => ensure_token.column,
+            :resource => resource,
+          }
+        end
+      end
+    end
+  end
+
+  def fix(problem)
+    first_param_name_token = tokens[problem[:resource][:start]].next_token_of(:NAME)
+    first_param_comma_token = first_param_name_token.next_token_of(:COMMA)
+    ensure_param_name_token = first_param_comma_token.next_token_of(:NAME, :value => 'ensure')
+    ensure_param_comma_token = ensure_param_name_token.next_token_of([:COMMA, :SEMIC])
+
+    if first_param_name_token.nil? or first_param_comma_token.nil? or ensure_param_name_token.nil? or ensure_param_comma_token.nil?
+      raise PuppetLint::NoFix
+    end
+
+    first_param_name_idx = tokens.index(first_param_name_token)
+    first_param_comma_idx = tokens.index(first_param_comma_token)
+    ensure_param_name_idx = tokens.index(ensure_param_name_token)
+    ensure_param_comma_idx = tokens.index(ensure_param_comma_token)
+
+    # Flip params
+    prev_token = first_param_name_token.prev_token
+    first_param_name_token.prev_token = ensure_param_name_token.prev_token
+    ensure_param_name_token.prev_token = prev_token
+
+    prev_code_token = first_param_name_token.prev_code_token
+    first_param_name_token.prev_code_token = ensure_param_name_token.prev_code_token
+    ensure_param_name_token.prev_code_token = prev_code_token
+
+    next_token = first_param_comma_token.next_token
+    first_param_comma_token = ensure_param_comma_token.next_token
+    ensure_param_comma_token.next_token = next_token
+
+    next_code_token = first_param_comma_token.next_code_token
+    first_param_comma_code_token = ensure_param_comma_token.next_code_token
+    ensure_param_comma_token.next_code_token = next_code_token
+
+    # Update index
+    ensure_tmp = tokens.slice!(ensure_param_name_idx..ensure_param_comma_idx-1)
+    first_tmp = tokens.slice!(first_param_name_idx..first_param_comma_idx-1)
+    ensure_tmp.reverse_each do |item|
+      tokens.insert(first_param_name_idx, item)
+    end
+    first_tmp.reverse_each do |item|
+      tokens.insert(ensure_param_name_idx + ensure_tmp.length - first_tmp.length, item)
+    end
+  end
+end

data/lib/puppet-lint/plugins/check_resources/ensure_not_symlink_target.rb

@@ -0,0 +1,44 @@
+# Public: Check the tokens of each File resource instance for an ensure
+# parameter and record a warning if the value of that parameter looks like
+# a symlink target (starts with a '/').
+#
+# https://docs.puppet.com/guides/style_guide.html#symbolic-links
+PuppetLint.new_check(:ensure_not_symlink_target) do
+  def check
+    resource_indexes.each do |resource|
+      if resource[:type].value == "file"
+        resource[:param_tokens].select { |param_token|
+          param_token.value == 'ensure'
+        }.each do |ensure_token|
+          value_token = ensure_token.next_code_token.next_code_token
+          if value_token.value.start_with? '/'
+            notify :warning, {
+              :message     => 'symlink target specified in ensure attr',
+              :line        => value_token.line,
+              :column      => value_token.column,
+              :param_token => ensure_token,
+              :value_token => value_token,
+            }
+          end
+        end
+      end
+    end
+  end
+
+  def fix(problem)
+    index = tokens.index(problem[:value_token])
+
+    [
+      PuppetLint::Lexer::Token.new(:NAME, 'symlink', 0, 0),
+      PuppetLint::Lexer::Token.new(:COMMA, ',', 0, 0),
+      PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0),
+      PuppetLint::Lexer::Token.new(:INDENT, problem[:param_token].prev_token.value.dup, 0, 0),
+      PuppetLint::Lexer::Token.new(:NAME, 'target', 0, 0),
+      PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', 0, 0),
+      PuppetLint::Lexer::Token.new(:FARROW, '=>', 0, 0),
+      PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', 0, 0),
+    ].reverse.each do |new_token|
+      tokens.insert(index, new_token)
+    end
+  end
+end

data/lib/puppet-lint/plugins/check_resources/file_mode.rb

@@ -0,0 +1,42 @@
+# Public: Check the tokens of each File resource instance for a mode
+# parameter and if found, record a warning if the value of that parameter is
+# not a 4 digit octal value (0755) or a symbolic mode ('o=rwx,g+r').
+#
+# https://docs.puppet.com/guides/style_guide.html#file-modes
+PuppetLint.new_check(:file_mode) do
+  MSG = 'mode should be represented as a 4 digit octal value or symbolic mode'
+  SYM_RE = "([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*"
+  IGNORE_TYPES = Set[:VARIABLE, :UNDEF, :FUNCTION_NAME]
+  MODE_RE = Regexp.new(/\A([0-7]{4}|#{SYM_RE})\Z/)
+
+  def check
+    resource_indexes.each do |resource|
+      if resource[:type].value == "file" or resource[:type].value == "concat"
+        resource[:param_tokens].select { |param_token|
+          param_token.value == 'mode'
+        }.each do |param_token|
+          value_token = param_token.next_code_token.next_code_token
+
+          break if IGNORE_TYPES.include?(value_token.type)
+          break if value_token.value =~ MODE_RE
+
+          notify :warning, {
+            :message => MSG,
+            :line    => value_token.line,
+            :column  => value_token.column,
+            :token   => value_token,
+          }
+        end
+      end
+    end
+  end
+
+  def fix(problem)
+    if problem[:token].value =~ /\A[0-7]{3}\Z/
+      problem[:token].type = :SSTRING
+      problem[:token].value = "0#{problem[:token].value.to_s}"
+    else
+      raise PuppetLint::NoFix
+    end
+  end
+end

data/lib/puppet-lint/plugins/check_resources/unquoted_file_mode.rb

@@ -0,0 +1,31 @@
+# Public: Check the tokens of each File resource instance for a mode
+# parameter and if found, record a warning if the value of that parameter is
+# not a quoted string.
+#
+# https://docs.puppet.com/guides/style_guide.html#file-modes
+PuppetLint.new_check(:unquoted_file_mode) do
+  TOKEN_TYPES = Set[:NAME, :NUMBER]
+
+  def check
+    resource_indexes.each do |resource|
+      if resource[:type].value == "file" or resource[:type].value == "concat"
+        resource[:param_tokens].select { |param_token|
+          param_token.value == 'mode' &&
+            TOKEN_TYPES.include?(param_token.next_code_token.next_code_token.type)
+        }.each do |param_token|
+          value_token = param_token.next_code_token.next_code_token
+          notify :warning, {
+            :message => 'unquoted file mode',
+            :line    => value_token.line,
+            :column  => value_token.column,
+            :token   => value_token,
+          }
+        end
+      end
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end

data/lib/puppet-lint/plugins/check_resources/unquoted_resource_title.rb

@@ -0,0 +1,22 @@
+# Public: Check the manifest tokens for any resource titles / namevars that
+# are not quoted and record a warning for each instance found.
+#
+# https://docs.puppet.com/guides/style_guide.html#resource-names
+PuppetLint.new_check(:unquoted_resource_title) do
+  def check
+    title_tokens.each do |token|
+      if token.type == :NAME
+        notify :warning, {
+          :message => 'unquoted resource title',
+          :line    => token.line,
+          :column  => token.column,
+          :token   => token,
+        }
+      end
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end

data/lib/puppet-lint/plugins/check_strings/double_quoted_strings.rb

@@ -0,0 +1,27 @@
+# Public: Check the manifest tokens for any double quoted strings that don't
+# contain any variables or common escape characters and record a warning for
+# each instance found.
+#
+# https://docs.puppet.com/guides/style_guide.html#quoting
+PuppetLint.new_check(:double_quoted_strings) do
+  def check
+    tokens.select { |token|
+      token.type == :STRING
+    }.map { |token|
+      [token, token.value.gsub(' '*token.column, "\n")]
+    }.select { |token, sane_value|
+      sane_value[/(\\\$|\\"|\\'|'|\r|\t|\\t|\n|\\n|\\\\)/].nil?
+    }.each do |token, sane_value|
+      notify :warning, {
+        :message => 'double quoted string containing no variables',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      }
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end

data/lib/puppet-lint/plugins/check_strings/only_variable_string.rb

@@ -0,0 +1,63 @@
+# Public: Check the manifest tokens for double quoted strings that contain
+# a single variable only and record a warning for each instance found.
+#
+# https://docs.puppet.com/guides/style_guide.html#quoting
+PuppetLint.new_check(:only_variable_string) do
+  VAR_TYPES = Set[:VARIABLE, :UNENC_VARIABLE]
+
+  def check
+    tokens.each_with_index do |start_token, start_token_idx|
+      if start_token.type == :DQPRE and start_token.value == ''
+        var_token = start_token.next_token
+        if VAR_TYPES.include? var_token.type
+          eos_offset = 2
+          loop do
+            eos_token = tokens[start_token_idx + eos_offset]
+            case eos_token.type
+            when :LBRACK
+              eos_offset += 3
+            when :DQPOST
+              if eos_token.value == ''
+                if eos_token.next_code_token && eos_token.next_code_token.type == :FARROW
+                  break
+                end
+                notify :warning, {
+                  :message     => 'string containing only a variable',
+                  :line        => var_token.line,
+                  :column      => var_token.column,
+                  :start_token => start_token,
+                  :var_token   => var_token,
+                  :end_token   => eos_token,
+                }
+              end
+              break
+            else
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def fix(problem)
+    prev_token = problem[:start_token].prev_token
+    prev_code_token = problem[:start_token].prev_code_token
+    next_token = problem[:end_token].next_token
+    next_code_token = problem[:end_token].next_code_token
+    var_token = problem[:var_token]
+
+    tokens.delete(problem[:start_token])
+    tokens.delete(problem[:end_token])
+
+    prev_token.next_token = var_token unless prev_token.nil?
+    prev_code_token.next_code_token = var_token unless prev_code_token.nil?
+    next_code_token.prev_code_token = var_token unless next_code_token.nil?
+    next_token.prev_token = var_token unless next_token.nil?
+    var_token.type = :VARIABLE
+    var_token.next_token = next_token
+    var_token.next_code_token = next_code_token
+    var_token.prev_code_token = prev_code_token
+    var_token.prev_token = prev_token
+  end
+end