halyard-puppet-lint 1.2.0

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

@@ -0,0 +1,55 @@
+# Public: Check the manifest tokens for any comments started with slashes
+# (//) and record a warning for each instance found.
+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.
+PuppetLint.new_check(:star_comments) do
+  def check
+    tokens.select { |token|
+      token.type == :MLCOMMENT
+    }.each do |token|
+      notify :warning, {
+        :message => '/* */ comment found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      }
+    end
+  end
+
+  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}"
+
+    index = tokens.index(problem[:token].next_token)
+    comment_lines.reverse.each do |line|
+      [
+        PuppetLint::Lexer::Token.new(:COMMENT, " #{line}", 0, 0),
+        PuppetLint::Lexer::Token.new(:INDENT, problem[:token].prev_token.value.dup, 0, 0),
+        PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0),
+      ].each do |new_token|
+        tokens.insert(index, new_token)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# Public: Test the manifest tokens for any selectors embedded within resource
+# declarations and record a warning for each instance found.
+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.
+PuppetLint.new_check(:case_without_default) do
+  def check
+    case_indexes = []
+
+    tokens.each_index do |token_idx|
+      if tokens[token_idx].type == :CASE
+        depth = 0
+        tokens[(token_idx + 1)..-1].each_index do |case_token_idx|
+          idx = case_token_idx + token_idx + 1
+          if tokens[idx].type == :LBRACE
+            depth += 1
+          elsif tokens[idx].type == :RBRACE
+            depth -= 1
+            if depth == 0
+              case_indexes << {:start => token_idx, :end => idx}
+              break
+            end
+          end
+        end
+      end
+    end
+
+    case_indexes.each_with_index do |kase,kase_index|
+      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]]
+      end
+
+      unless case_tokens.index { |r| r.type == :DEFAULT }
+        notify :warning, {
+          :message => 'case statement without a default case',
+          :line    => case_tokens.first.line,
+          :column  => case_tokens.first.column,
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# Public: Check the manifest tokens for any class or defined type that does not
+# have a comment directly above it (hopefully, explaining the usage of it) and
+# record a warning for each instance found.
+PuppetLint.new_check(:documentation) do
+  COMMENT_TOKENS = Set[:COMMENT, :MLCOMMENT, :SLASH_COMMENT]
+  WHITESPACE_TOKENS = Set[:WHITESPACE, :NEWLINE, :INDENT]
+
+  def check
+    (class_indexes + defined_type_indexes).each do |item_idx|
+      prev_token = item_idx[:tokens].first.prev_token
+      while (!prev_token.nil?) && WHITESPACE_TOKENS.include?(prev_token.type)
+        prev_token = prev_token.prev_token
+      end
+
+      unless (!prev_token.nil?) && COMMENT_TOKENS.include?(prev_token.type)
+        first_token = item_idx[:tokens].first
+        if first_token.type == :CLASS
+          type = 'class'
+        else
+          type = 'defined type'
+        end
+
+        notify :warning, {
+          :message => "#{type} not documented",
+          :line    => first_token.line,
+          :column  => first_token.column,
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# Public: Check the manifest for unquoted node names and record a warning for
+# each instance found.
+PuppetLint.new_check(:unquoted_node_name) do
+  def check
+    node_tokens = tokens.select { |token| token.type == :NODE }
+    node_tokens.each do |node|
+      node_token_idx = tokens.index(node)
+      node_lbrace_tok = tokens[node_token_idx..-1].find { |token| token.type == :LBRACE }
+      node_lbrace_idx = tokens.index(node_lbrace_tok)
+
+      tokens[node_token_idx..node_lbrace_idx].select { |token|
+        token.type == :NAME
+      }.each do |token|
+        unless token.value == 'default'
+          notify :warning, {
+            :message => 'unquoted node name found',
+            :line    => token.line,
+            :column  => token.column,
+            :token   => token,
+          }
+        end
+      end
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end

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

@@ -0,0 +1,194 @@
+# Public: Check the manifest tokens for any resource titles / namevars that
+# are not quoted and record a warning for each instance found.
+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
+
+# 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.
+PuppetLint.new_check(:ensure_first_param) do
+  def check
+    resource_indexes.each do |resource|
+      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,
+          }
+        end
+      end
+    end
+  end
+end
+
+# Public: Check the tokens of each resource instance for any duplicate
+# parameters and record a warning for each instance found.
+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
+
+# 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.
+PuppetLint.new_check(:unquoted_file_mode) do
+  TOKEN_TYPES = Set[:NAME, :NUMBER]
+
+  def check
+    resource_indexes.each do |resource|
+      if resource[:type].value == "file"
+        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
+
+# 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').
+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]
+  MODE_RE = Regexp.new(/\A([0-7]{4}|#{SYM_RE})\Z/)
+
+  def check
+    resource_indexes.each do |resource|
+      if resource[:type].value == "file"
+        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
+
+# 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 '/').
+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, problem[:param_token].next_token.value.dup, 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_strings.rb

@@ -0,0 +1,174 @@
+# 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.
+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
+
+# Public: Check the manifest tokens for double quoted strings that contain
+# a single variable only and record a warning for each instance found.
+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
+
+# Public: Check the manifest tokens for any variables in a string that have
+# not been enclosed by braces ({}) and record a warning for each instance
+# found.
+PuppetLint.new_check(:variables_not_enclosed) do
+  def check
+    tokens.select { |r|
+      r.type == :UNENC_VARIABLE
+    }.each do |token|
+      notify :warning, {
+        :message => 'variable not enclosed in {}',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      }
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = :VARIABLE
+  end
+end
+
+# Public: Check the manifest tokens for any single quoted strings containing
+# a enclosed variable and record an error for each instance found.
+PuppetLint.new_check(:single_quote_string_with_variables) do
+  def check
+    tokens.select { |r|
+      r.type == :SSTRING && r.value.include?('${')
+    }.each do |token|
+      notify :error, {
+        :message => 'single quoted string containing a variable found',
+        :line    => token.line,
+        :column  => token.column,
+      }
+    end
+  end
+end
+
+# Public: Check the manifest tokens for any double or single quoted strings
+# containing only a boolean value and record a warning for each instance
+# found.
+PuppetLint.new_check(:quoted_booleans) do
+  STRING_TYPES = Set[:STRING, :SSTRING]
+  BOOLEANS = Set['true', 'false']
+
+  def check
+    tokens.select { |r|
+      STRING_TYPES.include?(r.type) && BOOLEANS.include?(r.value)
+    }.each do |token|
+      notify :warning, {
+        :message => 'quoted boolean value found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      }
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = problem[:token].value.upcase.to_sym
+  end
+end
+
+# Public: Check the manifest tokens for any puppet:// URL strings where the
+# path section doesn't start with modules/ and record a warning for each
+# instance found.
+PuppetLint.new_check(:puppet_url_without_modules) do
+  def check
+    tokens.select { |token|
+      (token.type == :SSTRING || token.type == :STRING || token.type == :DQPRE) && token.value.start_with?('puppet://')
+    }.reject { |token|
+      token.value[/puppet:\/\/.*?\/(.+)/, 1].start_with?('modules/') unless token.value[/puppet:\/\/.*?\/(.+)/, 1].nil?
+    }.each do |token|
+      notify :warning, {
+        :message => 'puppet:// URL without modules/ found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      }
+    end
+  end
+
+  def fix(problem)
+    problem[:token].value.gsub!(/(puppet:\/\/.*?\/)/, '\1modules/')
+  end
+end