puppet-lint 0.1.13 → 0.2.0.pre1

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

@@ -1,49 +1,80 @@
 class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
-  if Puppet::PUPPETVERSION !~ /^0\.2/
-    check 'right_to_left_relationship' do
-      tokens.select { |r| r.first == :OUT_EDGE }.each do |token|
-        notify :warning, :message =>  "right-to-left (<-) relationship", :linenumber => token.last[:line]
-      end
+  # Public: Test the manifest tokens for any right-to-left (<-) chaining
+  # operators and record a warning for each instance found.
+  #
+  # Returns nothing.
+  check 'right_to_left_relationship' do
+    tokens.select { |r| r.type == :OUT_EDGE }.each do |token|
+      notify :warning, {
+        :message    =>  'right-to-left (<-) relationship',
+        :linenumber => token.line,
+        :column     => token.column,
+      }
     end
   end
 
+  # Public: Test the manifest tokens for any classes or defined types that are
+  # not in an appropriately named file for the autoloader to detect and record
+  # an error of each instance found.
+  #
+  # Returns nothing.
   check 'autoloader_layout' do
-    unless fullpath == ""
+    unless fullpath == ''
       (class_indexes + defined_type_indexes).each do |class_idx|
-        title_token = tokens[class_idx[:start]+1]
-        split_title = title_token.last[:value].split('::')
+        class_tokens = tokens[class_idx[:start]..class_idx[:end]]
+        title_token = class_tokens[class_tokens.index { |r| r.type == :NAME }]
+        split_title = title_token.value.split('::')
+        mod = split_title.first
         if split_title.length > 1
-          expected_path = "#{split_title.first}/manifests/#{split_title[1..-1].join('/')}.pp"
+          expected_path = "#{mod}/manifests/#{split_title[1..-1].join('/')}.pp"
         else
-          expected_path = "#{title_token.last[:value]}/manifests/init.pp"
+          expected_path = "#{title_token.value}/manifests/init.pp"
         end
 
         unless fullpath.end_with? expected_path
-          notify :error, :message =>  "#{title_token.last[:value]} not in autoload module layout", :linenumber => title_token.last[:line]
+          notify :error, {
+            :message    => "#{title_token.value} not in autoload module layout",
+            :linenumber => title_token.line,
+            :column     => title_token.column,
+          }
         end
       end
     end
   end
 
+  # Public: Test the manifest tokens for any parameterised classes or defined
+  # types that take parameters and record a warning if there are any optional
+  # parameters listed before required parameters.
+  #
+  # Returns nothing.
   check 'parameter_order' do
     (class_indexes + defined_type_indexes).each do |class_idx|
       token_idx = class_idx[:start]
-      header_end_idx = tokens[token_idx..-1].index { |r| r.first == :LBRACE }
-      lparen_idx = tokens[token_idx..(header_end_idx + token_idx)].index { |r| r.first == :LPAREN }
-      rparen_idx = tokens[token_idx..(header_end_idx + token_idx)].rindex { |r| r.first == :RPAREN }
+      header_end_idx = tokens[token_idx..-1].index { |r| r.type == :LBRACE }
+      header_tokens = tokens[token_idx..header_end_idx].reject { |r|
+        formatting_tokens.include?(r.type)
+      }
+      lparen_idx = header_tokens.index { |r| r.type == :LPAREN }
+      rparen_idx = header_tokens.rindex { |r| r.type == :RPAREN }
 
       unless lparen_idx.nil? or rparen_idx.nil?
-        param_tokens = tokens[lparen_idx..rparen_idx]
+        param_tokens = header_tokens[lparen_idx..rparen_idx]
         param_tokens.each_index do |param_tokens_idx|
           this_token = param_tokens[param_tokens_idx]
           next_token = param_tokens[param_tokens_idx+1]
           prev_token = param_tokens[param_tokens_idx-1]
-          if this_token.first == :VARIABLE
+          if this_token.type == :VARIABLE
             unless next_token.nil?
-              if next_token.first == :COMMA or next_token.first == :RPAREN
-                unless param_tokens[0..param_tokens_idx].rindex { |r| r.first == :EQUALS }.nil?
-                  unless prev_token.nil? or prev_token.first == :EQUALS
-                    notify :warning, :message =>  "optional parameter listed before required parameter", :linenumber => this_token.last[:line]
+              if next_token.type == :COMMA or next_token.type == :RPAREN
+                prev_tokens = param_tokens[0..param_tokens_idx]
+                unless prev_tokens.rindex { |r| r.type == :EQUALS }.nil?
+                  unless prev_token.nil? or prev_token.type == :EQUALS
+                    msg = 'optional parameter listed before required parameter'
+                    notify :warning, {
+                      :message    => msg,
+                      :linenumber => this_token.line,
+                      :column     => this_token.column,
+                    }
                   end
                 end
               end
@@ -54,57 +85,107 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
     end
   end
 
+  # Public: Test the manifest tokens for any classes that inherit across
+  # namespaces and record a warning for each instance found.
+  #
+  # Returns nothing.
   check 'inherits_across_namespaces' do
     class_indexes.each do |class_idx|
-      token_idx = class_idx[:start]
-      if tokens[token_idx+2].first == :INHERITS
-        class_name = tokens[token_idx+1].last[:value]
-        inherited_class = tokens[token_idx+3].last[:value]
+      class_tokens = tokens[class_idx[:start]..class_idx[:end]].reject { |r|
+        formatting_tokens.include?(r.type)
+      }
+
+      if class_tokens[2].type == :INHERITS
+        class_name = class_tokens[1].value
+        inherited_class = class_tokens[3].value
 
         unless class_name =~ /^#{inherited_class}::/
-          notify :warning, :message =>  "class inherits across namespaces", :linenumber => tokens[token_idx].last[:line]
+          notify :warning, {
+            :message    => "class inherits across namespaces",
+            :linenumber => class_tokens[3].line,
+            :column     => class_tokens[3].column,
+          }
         end
       end
     end
   end
 
+  # Public: Test the manifest tokens for any classes or defined types that are
+  # defined inside another class.
+  #
+  # Returns nothing.
   check 'nested_classes_or_defines' do
     class_indexes.each do |class_idx|
-      class_tokens = tokens[class_idx[:start]..class_idx[:end]]
-      class_tokens[1..-1].each_index do |token_idx|
-        token = class_tokens[1..-1][token_idx]
-        next_token = class_tokens[1..-1][token_idx + 1]
-
-        if token.first == :CLASS
-          if next_token.first != :LBRACE
-            notify :warning, :message =>  "class defined inside a class", :linenumber => token.last[:line]
+      # Skip the first token so that we don't pick up the first :CLASS
+      class_tokens = tokens[class_idx[:start]+1..class_idx[:end]].reject { |r|
+        formatting_tokens.include?(r.type)
+      }
+
+      class_tokens.each_index do |token_idx|
+        token = class_tokens[token_idx]
+        next_token = class_tokens[token_idx + 1]
+
+        if token.type == :CLASS
+          if next_token.type != :LBRACE
+            notify :warning, {
+              :message    => "class defined inside a class",
+              :linenumber => token.line,
+              :column     => token.column,
+            }
           end
         end
 
-        if token.first == :DEFINE
-          notify :warning, :message =>  "define defined inside a class", :linenumber => token.last[:line]
+        if token.type == :DEFINE
+          notify :warning, {
+            :message    => "define defined inside a class",
+            :linenumber => token.line,
+            :column     => token.column,
+          }
         end
       end
     end
   end
 
+  # Public: Test the manifest tokens for any variables that are referenced in
+  # the manifest.  If the variables are not fully qualified or one of the
+  # variables automatically created in the scope, check that they have been
+  # defined in the local scope and record a warning for each variable that has
+  # not.
+  #
+  # Returns nothing.
   check 'variable_scope' do
+    variables_in_scope = [
+      'name',
+      'title',
+      'module_name',
+      'environment',
+      'clientcert',
+      'clientversion',
+      'servername',
+      'serverip',
+      'serverversion',
+      'caller_module_name',
+    ]
     (class_indexes + defined_type_indexes).each do |idx|
       object_tokens = tokens[idx[:start]..idx[:end]]
-      variables_in_scope = ['name', 'title', 'module_name', 'environment', 'clientcert', 'clientversion', 'servername', 'serverip', 'serverversion', 'caller_module_name']
+      object_tokens.reject! { |r| formatting_tokens.include?(r.type) }
       referenced_variables = []
-      header_end_idx = object_tokens.index { |r| r.first == :LBRACE }
-      lparen_idx = object_tokens[0..header_end_idx].index { |r| r.first == :LPAREN }
-      rparen_idx = object_tokens[0..header_end_idx].rindex { |r| r.first == :RPAREN }
+      header_end_idx = object_tokens.index { |r| r.type == :LBRACE }
+      lparen_idx = object_tokens[0..header_end_idx].index { |r|
+        r.type == :LPAREN
+      }
+      rparen_idx = object_tokens[0..header_end_idx].rindex { |r|
+        r.type == :RPAREN
+      }
 
       unless lparen_idx.nil? or rparen_idx.nil?
         param_tokens = object_tokens[lparen_idx..rparen_idx]
         param_tokens.each_index do |param_tokens_idx|
           this_token = param_tokens[param_tokens_idx]
           next_token = param_tokens[param_tokens_idx+1]
-          if this_token.first == :VARIABLE
-            if [:COMMA, :EQUALS, :RPAREN].include? next_token.first
-              variables_in_scope << this_token.last[:value]
+          if this_token.type == :VARIABLE
+            if [:COMMA, :EQUALS, :RPAREN].include? next_token.type
+              variables_in_scope << this_token.value
             end
           end
         end
@@ -114,20 +195,25 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
         this_token = object_tokens[object_token_idx]
         next_token = object_tokens[object_token_idx + 1]
 
-        if this_token.first == :VARIABLE
-          if next_token.first == :EQUALS
-            variables_in_scope << this_token.last[:value]
+        if this_token.type == :VARIABLE
+          if next_token.type == :EQUALS
+            variables_in_scope << this_token.value
           else
             referenced_variables << this_token
           end
         end
       end
 
+      msg = "top-scope variable being used without an explicit namespace"
       referenced_variables.each do |token|
-        unless token.last[:value].include? '::'
-          unless variables_in_scope.include? token.last[:value]
-            unless token.last[:value] =~ /\d+/
-              notify :warning, :message =>  "top-scope variable being used without an explicit namespace", :linenumber => token.last[:line]
+        unless token.value.include? '::'
+          unless variables_in_scope.include? token.value
+            unless token.value =~ /\d+/
+              notify :warning, {
+                :message    => msg,
+                :linenumber => token.line,
+                :column     => token.column,
+              }
             end
           end
         end

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

@@ -1,14 +1,24 @@
 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
     resource_indexes.each do |resource|
-      resource_tokens = tokens[resource[:start]..resource[:end]]
+      resource_tokens = tokens[resource[:start]..resource[:end]].reject { |r|
+        formatting_tokens.include? r.type
+      }
 
       resource_tokens.each_index do |resource_token_idx|
-        if resource_tokens[resource_token_idx].first == :FARROW
-          if resource_tokens[resource_token_idx + 1].first == :VARIABLE
+        if resource_tokens[resource_token_idx].type == :FARROW
+          if resource_tokens[resource_token_idx + 1].type == :VARIABLE
             unless resource_tokens[resource_token_idx + 2].nil?
-              if resource_tokens[resource_token_idx + 2].first == :QMARK
-                notify :warning, :message =>  "selector inside resource block", :linenumber => resource_tokens[resource_token_idx].last[:line]
+              if resource_tokens[resource_token_idx + 2].type == :QMARK
+                notify :warning, {
+                  :message    => 'selector inside resource block',
+                  :linenumber => resource_tokens[resource_token_idx].line,
+                  :column     => resource_tokens[resource_token_idx].column,
+                }
               end
             end
           end
@@ -17,26 +27,23 @@ class PuppetLint::Plugins::CheckConditionals < PuppetLint::CheckPlugin
     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
     case_indexes = []
 
     tokens.each_index do |token_idx|
-      if tokens[token_idx].first == :COLON
-        # gather a list of start and end indexes for resource attribute blocks
-        if tokens[token_idx+1].first != :LBRACE
-          resource_indexes << {:start => token_idx+1, :end => tokens[token_idx+1..-1].index { |r| [:SEMIC, :RBRACE].include? r.first }+token_idx}
-        end
-      end
-
-      if tokens[token_idx].first == :CASE
-        lbrace_count = 0
-        tokens[token_idx+1..-1].each_index do |case_token_idx|
-          idx = case_token_idx + token_idx
-          if tokens[idx].first == :LBRACE
-            lbrace_count += 1
-          elsif tokens[idx].first == :RBRACE
-            lbrace_count -= 1
-            if lbrace_count == 0
+      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
@@ -48,8 +55,12 @@ class PuppetLint::Plugins::CheckConditionals < PuppetLint::CheckPlugin
     case_indexes.each do |kase|
       case_tokens = tokens[kase[:start]..kase[:end]]
 
-      unless case_tokens.index { |r| r.first == :DEFAULT }
-        notify :warning, :message =>  "case statement without a default case", :linenumber => case_tokens.first.last[:line]
+      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,
+        }
       end
     end
   end

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

@@ -1,39 +1,79 @@
-# Resources
-# http://docs.puppetlabs.com/guides/style_guide.html#resources
-
 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
     title_tokens.each do |token|
-      if token.first == :NAME
-        notify :warning, :message =>  "unquoted resource title", :linenumber => token.last[:line]
+      if token.type == :NAME
+        notify :warning, {
+          :message    => 'unquoted resource title',
+          :linenumber => token.line,
+          :column     => token.column,
+        }
       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]]
-      ensure_attr_index = resource_tokens.index { |token| token.first == :NAME and token.last[:value] == 'ensure' }
+      resource_tokens = tokens[resource[:start]..resource[:end]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+
+      ensure_attr_index = resource_tokens.index { |token|
+        token.type == :NAME and token.value == 'ensure'
+      }
+
       unless ensure_attr_index.nil?
         if ensure_attr_index > 1
-          ensure_attr_line_no = resource_tokens[ensure_attr_index].last[:line]
-          notify :warning, :message =>  "ensure found on line but it's not the first attribute", :linenumber => ensure_attr_line_no
+          ensure_token = resource_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,
+          }
         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]]
-      resource_type_token = tokens[tokens[0..resource[:start]].rindex { |r| r.first == :LBRACE } - 1]
-      if resource_type_token.last[:value] == "file"
+      resource_tokens = tokens[resource[:start]..resource[:end]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+
+      stripped_tokens = tokens[0..resource[:start]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+
+      res_type_idx = stripped_tokens.rindex { |r|
+        r.type == :LBRACE
+      } - 1
+
+      resource_type_token = stripped_tokens[res_type_idx]
+      if resource_type_token.value == "file"
         resource_tokens.each_index do |resource_token_idx|
           attr_token = resource_tokens[resource_token_idx]
-          if attr_token.first == :NAME and attr_token.last[:value] == 'mode'
+          if attr_token.type == :NAME and attr_token.value == 'mode'
             value_token = resource_tokens[resource_token_idx + 2]
-            if value_token.first == :NAME
-              notify :warning, :message =>  "unquoted file mode", :linenumber => value_token.last[:line]
+            if value_token.type == :NAME
+              notify :warning, {
+                :message    => 'unquoted file mode',
+                :linenumber => value_token.line,
+                :column     => value_token.column,
+              }
             end
           end
         end
@@ -41,35 +81,81 @@ class PuppetLint::Plugins::CheckResources < PuppetLint::CheckPlugin
     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]]
-      resource_type_token = tokens[tokens[0..resource[:start]].rindex { |r| r.first == :LBRACE } - 1]
-      if resource_type_token.last[:value] == "file"
+      resource_tokens = tokens[resource[:start]..resource[:end]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+
+      stripped_tokens = tokens[0..resource[:start]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+
+      res_type_idx = stripped_tokens.rindex { |r|
+        r.type == :LBRACE
+      } - 1
+
+      resource_type_token = stripped_tokens[res_type_idx]
+      if resource_type_token.value == "file"
         resource_tokens.each_index do |resource_token_idx|
           attr_token = resource_tokens[resource_token_idx]
-          if attr_token.first == :NAME and attr_token.last[:value] == 'mode'
+          if attr_token.type == :NAME and attr_token.value == 'mode'
             value_token = resource_tokens[resource_token_idx + 2]
-            if value_token.last[:value] !~ /\d{4}/ and value_token.first != :VARIABLE and value_token.last[:value] !~ /^([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*$/
-              notify :warning, :message =>  "mode should be represented as a 4 digit octal value or symbolic file mode", :linenumber => value_token.last[:line]
-            end
+
+            break if value_token.value =~ /\d{4}/
+            break if value_token.type == :VARIABLE
+            break if value_token.value =~ sym_mode
+
+            notify :warning, {
+              :message    => msg,
+              :linenumber => value_token.line,
+              :column     => value_token.column,
+            }
           end
         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]]
-      resource_type_token = tokens[tokens[0..resource[:start]].rindex { |r| r.first == :LBRACE } - 1]
-      if resource_type_token.last[:value] == "file"
+      resource_tokens = tokens[resource[:start]..resource[:end]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+
+      stripped_tokens = tokens[0..resource[:start]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+
+      res_type_idx = stripped_tokens.rindex { |r|
+        r.type == :LBRACE
+      } - 1
+
+      resource_type_token = stripped_tokens[res_type_idx]
+      if resource_type_token.value == "file"
         resource_tokens.each_index do |resource_token_idx|
           attr_token = resource_tokens[resource_token_idx]
-          if attr_token.first == :NAME and attr_token.last[:value] == 'ensure'
+          if attr_token.type == :NAME and attr_token.value == 'ensure'
             value_token = resource_tokens[resource_token_idx + 2]
-            if value_token.last[:value].start_with? '/'
-              notify :warning, :message =>  "symlink target specified in ensure attr", :linenumber => value_token.last[:line]
+            if value_token.value.start_with? '/'
+              notify :warning, {
+                :message    => 'symlink target specified in ensure attr',
+                :linenumber => value_token.line,
+                :column     => value_token.column,
+              }
             end
           end
         end