puppet-lint 0.4.0.pre1 → 1.0.0

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

@@ -1,75 +1,62 @@
-class PuppetLint::Plugins::CheckStrings < PuppetLint::CheckPlugin
-  # 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.
-  #
-  # Returns nothing.
-  check 'double_quoted_strings' do
-    tokens.select { |r|
-      r.type == :STRING
-    }.each { |r|
-      r.value.gsub!(' '*r.column, "\n")
-    }.select { |r|
-      r.value[/(\t|\\t|\n|\\n)/].nil?
-    }.each do |token|
-      if PuppetLint.configuration.fix
-        token.type = :SSTRING
-        notify_type = :fixed
-      else
-        notify_type = :warning
-      end
-
-      notify notify_type, {
-        :message    => 'double quoted string containing no variables',
-        :linenumber => token.line,
-        :column     => token.column,
+# 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
 
-  # Public: Check the manifest tokens for double quoted strings that contain
-  # a single variable only and record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'only_variable_string' do
-    tokens.each_index do |token_idx|
-      token = tokens[token_idx]
-
-      if token.type == :DQPRE and token.value == ''
-        if {:VARIABLE => true, :UNENC_VARIABLE => true}.include? tokens[token_idx + 1].type
-          if tokens[token_idx + 2].type == :DQPOST
-            if tokens[token_idx + 2].value == ''
-              if PuppetLint.configuration.fix
-                prev_token = token.prev_token
-                prev_code_token = token.prev_code_token
-                next_token = token.next_token.next_token.next_token
-                next_code_token = token.next_token.next_token.next_code_token
-                var_token = token.next_token
+  def fix(problem)
+    problem[:token].type = :SSTRING
+  end
+end
 
-                tokens.delete_at(token_idx + 2)
-                tokens.delete_at(token_idx)
+# 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]
 
-                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
-                notify_type = :fixed
-                notify_token = var_token
-              else
-                notify_type = :warning
-                notify_token = tokens[token_idx + 1]
+  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
-
-              notify notify_type, {
-                :message    => 'string containing only a variable',
-                :linenumber => notify_token.line,
-                :column     => notify_token.column,
-              }
+              break
+            else
+              break
             end
           end
         end
@@ -77,66 +64,105 @@ class PuppetLint::Plugins::CheckStrings < PuppetLint::CheckPlugin
     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.
-  #
-  # Returns nothing.
-  check 'variables_not_enclosed' do
+  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|
-      if PuppetLint.configuration.fix
-        token.type = :VARIABLE
-        notify_type = :fixed
-      else
-        notify_type = :warning
-      end
-
-      notify notify_type, {
-        :message    => 'variable not enclosed in {}',
-        :linenumber => token.line,
-        :column     => token.column,
+      notify :warning, {
+        :message => 'variable not enclosed in {}',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
       }
     end
   end
 
-  # Public: Check the manifest tokens for any single quoted strings containing
-  # a enclosed variable and record an error for each instance found.
-  #
-  # Returns nothing.
-  check 'single_quote_string_with_variables' do
+  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',
-        :linenumber => token.line,
-        :column     => token.column,
+        :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']
 
-  # 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.
-  #
-  # Returns nothing.
-  check 'quoted_booleans' do
+  def check
     tokens.select { |r|
-      {:STRING => true, :SSTRING => true}.include?(r.type) && %w{true false}.include?(r.value)
+      STRING_TYPES.include?(r.type) && BOOLEANS.include?(r.value)
     }.each do |token|
-      if PuppetLint.configuration.fix
-        token.type = token.value.upcase.to_sym
-        notify_type = :fixed
-      else
-        notify_type = :warning
-      end
+      notify :warning, {
+        :message => 'quoted boolean value found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
+      }
+    end
+  end
 
-      notify notify_type, {
-        :message    => 'quoted boolean value found',
-        :linenumber => token.line,
-        :column     => token.column,
+  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.value.start_with?('puppet://')
+    }.reject { |token|
+      token.value[/puppet:\/\/.*?\/(.+)/, 1].start_with?('modules/')
+    }.each do |token|
+      notify :warning, {
+        :message => 'puppet:// URL without modules/ found',
+        :line    => token.line,
+        :column  => token.column,
       }
     end
   end

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

@@ -1,17 +1,17 @@
-class PuppetLint::Plugins::CheckVariables < PuppetLint::CheckPlugin
-  # Public: Test the manifest tokens for variables that contain a dash and
-  # record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'variable_contains_dash' do
+# Public: Test the manifest tokens for variables that contain a dash and
+# record a warning for each instance found.
+PuppetLint.new_check(:variable_contains_dash) do
+  VARIABLE_TYPES = Set[:VARIABLE, :UNENC_VARIABLE]
+
+  def check
     tokens.select { |r|
-      {:VARIABLE => true, :UNENC_VARIABLE => true}.include? r.type
+      VARIABLE_TYPES.include? r.type
     }.each do |token|
-      if token.value.match(/-/)
+      if token.value.gsub(/\[.+?\]/, '').match(/-/)
         notify :warning, {
-          :message    => 'variable contains a dash',
-          :linenumber => token.line,
-          :column     => token.column,
+          :message => 'variable contains a dash',
+          :line    => token.line,
+          :column  => token.column,
         }
       end
     end

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

@@ -1,116 +1,117 @@
-class PuppetLint::Plugins::CheckWhitespace < PuppetLint::CheckPlugin
-  # Check the raw manifest string for lines containing hard tab characters and
-  # record an error for each instance found.
-  #
-  # Returns nothing.
-  check 'hard_tabs' do
+# Public: Check the raw manifest string for lines containing hard tab
+# characters and record an error for each instance found.
+PuppetLint.new_check(:hard_tabs) do
+  WHITESPACE_TYPES = Set[:INDENT, :WHITESPACE]
+
+  def check
     tokens.select { |r|
-      [:INDENT, :WHITESPACE].include?(r.type) && r.value.include?("\t")
+      WHITESPACE_TYPES.include?(r.type) && r.value.include?("\t")
     }.each do |token|
-      if PuppetLint.configuration.fix
-        token.value.gsub!("\t", '  ')
-        notify_type = :fixed
-      else
-        notify_type = :error
-      end
-
-      notify notify_type, {
-        :message    => 'tab character found',
-        :linenumber => token.line,
-        :column     => token.column,
+      notify :error, {
+        :message => 'tab character found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
       }
     end
   end
 
-  # Check the manifest tokens for lines ending with whitespace and record an
-  # error for each instance found.
-  #
-  # Returns nothing.
-  check 'trailing_whitespace' do
+  def fix(problem)
+    problem[:token].value.gsub!("\t", '  ')
+  end
+end
+
+# Public: Check the manifest tokens for lines ending with whitespace and record
+# an error for each instance found.
+PuppetLint.new_check(:trailing_whitespace) do
+  def check
     tokens.select { |token|
       token.type == :WHITESPACE
     }.select { |token|
       token.next_token.nil? || token.next_token.type == :NEWLINE
     }.each do |token|
-      if PuppetLint.configuration.fix
-        notify_type = :fixed
-        prev_token = token.prev_token
-        next_token = token.next_token
-
-        tokens.delete(token)
-        prev_token.next_token = next_token
-
-        unless next_token.nil?
-          next_token.prev_token = prev_token
-        end
-      else
-        notify_type = :error
-      end
-
-      notify notify_type, {
-        :message    => 'trailing whitespace found',
-        :linenumber => token.line,
-        :column     => token.column,
+      notify :error, {
+        :message => 'trailing whitespace found',
+        :line    => token.line,
+        :column  => token.column,
+        :token   => token,
       }
     end
   end
 
-  # Test the raw manifest string for lines containing more than 80 characters
-  # and record a warning for each instance found.  The only exception to this
-  # rule is lines containing URLs which would hurt readability if split.
-  #
-  # Returns nothing.
-  check '80chars' do
+  def fix(problem)
+    prev_token = problem[:token].prev_token
+    next_token = problem[:token].next_token
+    prev_token.next_token = next_token
+    next_token.prev_token = prev_token unless next_token.nil?
+    tokens.delete(problem[:token])
+  end
+end
+
+# Public: Test the raw manifest string for lines containing more than 80
+# characters and record a warning for each instance found.  The only exceptions
+# to this rule are lines containing URLs and template() calls which would hurt
+# readability if split.
+PuppetLint.new_check(:'80chars') do
+  def check
     manifest_lines.each_with_index do |line, idx|
-      unless line =~ /:\/\//
+      unless line =~ /:\/\// || line =~ /template\(/
         if line.scan(/./mu).size > 80
           notify :warning, {
-            :message    => 'line has more than 80 characters',
-            :linenumber => idx + 1,
-            :column     => 80,
+            :message => 'line has more than 80 characters',
+            :line    => idx + 1,
+            :column  => 80,
           }
         end
       end
     end
   end
+end
 
-  # Check the manifest tokens for any indentation not using 2 space soft tabs
-  # and record an error for each instance found.
-  #
-  # Returns nothing.
-  check '2sp_soft_tabs' do
+# Public: Check the manifest tokens for any indentation not using 2 space soft
+# tabs and record an error for each instance found.
+PuppetLint.new_check(:'2sp_soft_tabs') do
+  def check
     tokens.select { |r|
       r.type == :INDENT
     }.reject { |r|
       r.value.length % 2 == 0
     }.each do |token|
       notify :error, {
-        :message    => 'two-space soft tabs not used',
-        :linenumber => token.line,
-        :column     => token.column,
+        :message => 'two-space soft tabs not used',
+        :line    => token.line,
+        :column  => token.column,
       }
     end
   end
+end
 
-  # Check the manifest tokens for any arrows (=>) in a grouping ({}) that are
-  # not aligned with other arrows in that grouping.
-  #
-  # Returns nothing.
-  check 'arrow_alignment' do
+# Public: Check the manifest tokens for any arrows (=>) in a grouping ({}) that
+# are not aligned with other arrows in that grouping.
+PuppetLint.new_check(:arrow_alignment) do
+  COMMENT_TYPES = Set[:COMMENT, :SLASH_COMMENT, :MLCOMMENT]
+
+  def check
     resource_indexes.each do |res_idx|
       indent_depth = [0]
       indent_depth_idx = 0
-      resource_tokens = tokens[res_idx[:start]..res_idx[:end]]
+      level_tokens = []
+      resource_tokens = res_idx[:tokens]
       resource_tokens.reject! do |token|
-        {:COMMENT => true, :SLASH_COMMENT => true, :MLCOMMENT => true}.include? token.type
+        COMMENT_TYPES.include? token.type
       end
 
       # If this is a single line resource, skip it
-      next if resource_tokens.select { |r| r.type == :NEWLINE }.empty?
+      first_arrow = resource_tokens.index { |r| r.type == :FARROW }
+      last_arrow = resource_tokens.rindex { |r| r.type == :FARROW }
+      next if first_arrow.nil?
+      next if last_arrow.nil?
+      next unless resource_tokens[first_arrow..last_arrow].any? { |r| r.type == :NEWLINE }
 
       resource_tokens.each_with_index do |token, idx|
         if token.type == :FARROW
-          indent_length = token.column
+          (level_tokens[indent_depth_idx] ||= []) << token
+          indent_length = token.prev_token.column + 1
 
           if indent_depth[indent_depth_idx] < indent_length
             indent_depth[indent_depth_idx] = indent_length
@@ -120,34 +121,27 @@ class PuppetLint::Plugins::CheckWhitespace < PuppetLint::CheckPlugin
           indent_depth_idx += 1
           indent_depth << 0
         elsif token.type == :RBRACE
-          indent_depth_idx -= 1
-        end
-      end
-
-      indent_depth_idx = 0
-      resource_tokens.each_with_index do |token, idx|
-        if token.type == :FARROW
-          indent_length = token.column
-          unless indent_depth[indent_depth_idx] == indent_length
-            if PuppetLint.configuration.fix
-              offset = indent_depth[indent_depth_idx] - indent_length
-              token.prev_token.value = token.prev_token.value + (' ' * offset)
-              notify_type = :fixed
-            else
-              notify_type = :warning
+          level_tokens[indent_depth_idx].each do |arrow_tok|
+            unless arrow_tok.column == indent_depth[indent_depth_idx]
+              notify :warning, {
+                :message      => 'indentation of => is not properly aligned',
+                :line         => arrow_tok.line,
+                :column       => arrow_tok.column,
+                :token        => arrow_tok,
+                :indent_depth => indent_depth[indent_depth_idx],
+              }
             end
-            notify notify_type, {
-              :message    => 'indentation of => is not properly aligned',
-              :linenumber => token.line,
-              :column     => token.column,
-            }
           end
-        elsif token.type == :LBRACE
-          indent_depth_idx += 1
-        elsif token.type == :RBRACE
+          indent_depth[indent_depth_idx] = 0
+          level_tokens[indent_depth_idx].clear
           indent_depth_idx -= 1
         end
       end
     end
   end
+
+  def fix(problem)
+    new_indent = ' ' * (problem[:indent_depth] - problem[:token].prev_token.column)
+    problem[:token].prev_token.value = new_indent
+  end
 end