puppet-lint 0.4.0.pre1 → 1.0.0

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

@@ -1,40 +1,55 @@
-class PuppetLint::Plugins::CheckComments < PuppetLint::CheckPlugin
-  # Public: Check the manifest tokens for any comments started with slashes
-  # (//) and record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'slash_comments' do
+# 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|
-      if PuppetLint.configuration.fix
-        token.type = :COMMENT
-        notify_type = :fixed
-      else
-        notify_type = :warning
-      end
-
-      notify notify_type, {
-        :message    => '// comment found',
-        :linenumber => token.line,
-        :column     => token.column,
+      notify :warning, {
+        :message => '// comment found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
       }
     end
   end
 
-  # Public: Check the manifest tokens for any comments encapsulated with
-  # slash-asterisks (/* */) and record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'star_comments' do
+  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',
-        :linenumber => token.line,
-        :column     => token.column,
+        :message => '/* */ comment found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
       }
     end
   end
+
+  def fix(problem)
+    comment_lines = problem[:token].value.split("\n")
+    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

@@ -1,21 +1,17 @@
-class PuppetLint::Plugins::CheckConditionals < PuppetLint::CheckPlugin
-  # Public: Test the manifest tokens for any selectors embedded within resource
-  # declarations and record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'selector_inside_resource' do
+# 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 = tokens[resource[:start]..resource[:end]]
-
-      resource_tokens.each do |token|
+      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',
-                  :linenumber => token.line,
-                  :column     => token.column,
+                  :message => 'selector inside resource block',
+                  :line    => token.line,
+                  :column  => token.column,
                 }
               end
             end
@@ -24,12 +20,12 @@ class PuppetLint::Plugins::CheckConditionals < PuppetLint::CheckPlugin
       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.
-  #
-  # Returns nothing.
-  check 'case_without_default' do
+# 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|
@@ -55,9 +51,9 @@ class PuppetLint::Plugins::CheckConditionals < PuppetLint::CheckPlugin
 
       unless case_tokens.index { |r| r.type == :DEFAULT }
         notify :warning, {
-          :message    => 'case statement without a default case',
-          :linenumber => case_tokens.first.line,
-          :column     => case_tokens.first.column,
+          :message => 'case statement without a default case',
+          :line    => case_tokens.first.line,
+          :column  => case_tokens.first.column,
         }
       end
     end

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

@@ -1,25 +1,19 @@
-class PuppetLint::Plugins::CheckDocumentation < PuppetLint::CheckPlugin
-  check 'documentation' do
-    comment_tokens = {
-      :COMMENT => true,
-      :MLCOMMENT => true,
-      :SLASH_COMMENT => true,
-    }
-
-    whitespace_tokens = {
-      :WHITESPACE => true,
-      :NEWLINE => true,
-      :INDENT => true,
-    }
+# 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 = tokens[item_idx[:start] - 1]
-      while (!prev_token.nil?) && whitespace_tokens.include?(prev_token.type)
+      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 = tokens[item_idx[:start]]
+      unless (!prev_token.nil?) && COMMENT_TOKENS.include?(prev_token.type)
+        first_token = item_idx[:tokens].first
         if first_token.type == :CLASS
           type = 'class'
         else
@@ -27,9 +21,9 @@ class PuppetLint::Plugins::CheckDocumentation < PuppetLint::CheckPlugin
         end
 
         notify :warning, {
-          :message    => "#{type} not documented",
-          :linenumber => first_token.line,
-          :column     => first_token.column,
+          :message => "#{type} not documented",
+          :line    => first_token.line,
+          :column  => first_token.column,
         }
       end
     end

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

@@ -0,0 +1,23 @@
+# 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
+    tokens.select { |r|
+      r.type == :NODE && r.next_code_token.type == :NAME
+    }.each do |token|
+      value_token = token.next_code_token
+      unless value_token.value == 'default'
+        notify :warning, {
+          :message => 'unquoted node name found',
+          :line    => value_token.line,
+          :column  => value_token.column,
+          :token   => value_token,
+        }
+      end
+    end
+  end
+
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end

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

@@ -1,208 +1,194 @@
-class PuppetLint::Plugins::CheckResources < PuppetLint::CheckPlugin
-  # Public: Check the manifest tokens for any resource titles / namevars that
-  # are not quoted and record a warning for each instance found.
-  #
-  # Return nothing.
-  check 'unquoted_resource_title' do
+# 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
-        if PuppetLint.configuration.fix
-          token.type = :SSTRING
-          notify_type = :fixed
-        else
-          notify_type = :warning
-        end
-
-        notify notify_type, {
-          :message    => 'unquoted resource title',
-          :linenumber => token.line,
-          :column     => token.column,
+        notify :warning, {
+          :message => 'unquoted resource title',
+          :line    => token.line,
+          :column  => token.column,
+          :token   => token,
         }
       end
     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.
-  #
-  # Returns nothing.
-  check 'ensure_first_param' do
-    resource_indexes.each do |resource|
-      resource_tokens = tokens[resource[:start]..resource[:end]]
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end
 
-      param_tokens = resource_tokens.select { |resource_token|
-        resource_token.type == :NAME && resource_token.next_code_token.type == :FARROW
-      }
-      ensure_attr_index = param_tokens.index { |resource_token|
-        resource_token.value == 'ensure'
+# 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 = param_tokens[ensure_attr_index]
+          ensure_token = resource[:param_tokens][ensure_attr_index]
           notify :warning, {
-            :message    => "ensure found on line but it's not the first attribute",
-            :linenumber => ensure_token.line,
-            :column     => ensure_token.column,
+            :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
 
-  check 'duplicate_params' do
+# 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|
-      resource_tokens = tokens[resource[:start]..resource[:end]].reject { |r|
-        formatting_tokens.include? r.type
-      }
-
       seen_params = {}
       level = 0
-      resource_tokens.each_with_index do |token, idx|
+
+      resource[:tokens].each_with_index do |token, idx|
         case token.type
         when :LBRACE
           level += 1
           next
         when :RBRACE
-          seen_params[level] = {}
+          seen_params.delete(level)
           level -= 1
           next
-        end
-        seen_params[level] ||= {}
-
-        if token.type == :FARROW
-          prev_token = resource_tokens[idx - 1]
+        when :FARROW
+          prev_token = token.prev_code_token
           next unless prev_token.type == :NAME
-          if seen_params[level].include? prev_token.value
+
+          if (seen_params[level] ||= Set.new).include?(prev_token.value)
             notify :error, {
-              :message    => 'duplicate parameter found in resource',
-              :linenumber => prev_token.line,
-              :column     => prev_token.column,
+              :message => 'duplicate parameter found in resource',
+              :line    => prev_token.line,
+              :column  => prev_token.column,
             }
           else
-            seen_params[level][prev_token.value] = true
+            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.
-  #
-  # Returns nothing.
-  check 'unquoted_file_mode' do
-    resource_indexes.each do |resource|
-      resource_tokens = tokens[resource[:start]..resource[:end]]
-      prev_tokens = tokens[0..resource[:start]]
+# 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]
 
-      lbrace_idx = prev_tokens.rindex { |r|
-        r.type == :LBRACE
-      }
-
-      resource_type_token = tokens[lbrace_idx].prev_code_token
-      if resource_type_token.value == "file"
-        resource_tokens.select { |resource_token|
-          resource_token.type == :NAME and resource_token.value == 'mode'
-        }.each do |resource_token|
-          value_token = resource_token.next_code_token.next_code_token
-          if {:NAME => true, :NUMBER => true}.include? value_token.type
-            if PuppetLint.configuration.fix
-              value_token.type = :SSTRING
-              notify_type = :fixed
-            else
-              notify_type = :warning
-            end
-
-            notify notify_type, {
-              :message    => 'unquoted file mode',
-              :linenumber => value_token.line,
-              :column     => value_token.column,
-            }
-          end
+  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
 
-  # 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').
-  #
-  # Returns nothing.
-  check 'file_mode' do
-    msg = 'mode should be represented as a 4 digit octal value or symbolic mode'
-    sym_mode = /\A([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*\Z/
-
-    resource_indexes.each do |resource|
-      resource_tokens = tokens[resource[:start]..resource[:end]]
-      prev_tokens = tokens[0..resource[:start]]
-
-      lbrace_idx = prev_tokens.rindex { |r|
-        r.type == :LBRACE
-      }
-
-      resource_type_token = tokens[lbrace_idx].prev_code_token
-      if resource_type_token.value == "file"
-        resource_tokens.select { |resource_token|
-          resource_token.type == :NAME and resource_token.value == 'mode'
-        }.each do |resource_token|
-          value_token = resource_token.next_code_token.next_code_token
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end
 
-          break if value_token.value =~ /\A[0-7]{4}\Z/
-          break if value_token.type == :VARIABLE
-          break if value_token.value =~ sym_mode
-          break if value_token.type == :UNDEF
+# 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/)
 
-          notify_type = :warning
+  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
 
-          if PuppetLint.configuration.fix && value_token.value =~ /\A[0-7]{3}\Z/
-            value_token.value = "0#{value_token.value.to_s}"
-            value_token.type = :SSTRING
-            notify_type = :fixed
-          end
+          break if IGNORE_TYPES.include?(value_token.type)
+          break if value_token.value =~ MODE_RE
 
-          notify notify_type, {
-            :message    => msg,
-            :linenumber => value_token.line,
-            :column     => value_token.column,
+          notify :warning, {
+            :message => MSG,
+            :line    => value_token.line,
+            :column  => value_token.column,
+            :token   => value_token,
           }
         end
       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 '/').
-  #
-  # Returns nothing.
-  check 'ensure_not_symlink_target' do
-    resource_indexes.each do |resource|
-      resource_tokens = tokens[resource[:start]..resource[:end]]
-      prev_tokens = tokens[0..resource[:start]]
-
-      lbrace_idx = prev_tokens.rindex { |r|
-        r.type == :LBRACE
-      }
+  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
 
-      resource_type_token = tokens[lbrace_idx].prev_code_token
-      if resource_type_token.value == "file"
-        resource_tokens.select { |resource_token|
-          resource_token.type == :NAME and resource_token.value == 'ensure'
+# 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',
-              :linenumber => value_token.line,
-              :column     => value_token.column,
+              :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