puppet-lint 0.2.0.pre1 → 0.2.0

data/lib/puppet-lint/lexer/token.rb

@@ -0,0 +1,62 @@
+class PuppetLint
+  class Lexer
+    class Token
+      # Internal: Returns the Symbol type of the Token.
+      attr_reader :type
+
+      # Internal: Returns the String value of the Token.
+      attr_reader :value
+
+      # Internal: Returns the Integer line number of the manifest text where
+      # the Token can be found.
+      attr_reader :line
+
+      # Internal: Returns the Integer column number of the line of the manifest
+      # text where the Token can be found.
+      attr_reader :column
+
+      # Internal: Gets/sets the next token in the manifest.
+      attr_accessor :next_token
+
+      # Internal: Gets/sets the previous token in the manifest.
+      attr_accessor :prev_token
+
+      # Internal: Gets/sets the next code token (skips whitespace, comments,
+      # etc) in the manifest.
+      attr_accessor :next_code_token
+
+      # Internal: Gets/sets the previous code tokne (skips whitespace,
+      # comments, etc) in the manifest.
+      attr_accessor :prev_code_token
+
+      # Internal: Initialise a new Token object.
+      #
+      # type   - An upper case Symbol describing the type of Token.
+      # value  - The String value of the Token.
+      # line   - The Integer line number where the Token can be found in the
+      #          manifest.
+      # column - The Integer number of characters from the start of the line to
+      #          the start of the Token.
+      #
+      # Returns the instantiated Token.
+      def initialize(type, value, line, column)
+        @value = value
+        @type = type
+        @line = line
+        @column = column
+        @next_token = nil
+        @prev_token = nil
+        @next_code_token = nil
+        @prev_code_token = nil
+      end
+
+      # Internal: Produce a human friendly description of the Token when
+      # inspected.
+      #
+      # Returns a String describing the Token.
+      def inspect
+        "<Token #{@type.inspect} (#{@value}) @#{@line}:#{@column}>"
+      end
+    end
+  end
+end

data/lib/puppet-lint/plugin.rb

@@ -19,18 +19,13 @@ end
 
 class PuppetLint::CheckPlugin
   include PuppetLint::Plugin
-  attr_reader :problems, :checks
+  attr_reader :problems
 
   def initialize
     @problems = []
-    @checks = []
     @default_info = {:check => 'unknown', :linenumber => 0}
   end
 
-  def register_check(check)
-    @checks << check
-  end
-
   #     notify(kind, message_hash)    #=> nil
   #
   # Adds the message to the problems array.
@@ -59,33 +54,34 @@ class PuppetLint::CheckPlugin
     @fileinfo = fileinfo
     @data = data
 
-    self.public_methods.select { |method|
-      method.to_s.start_with? 'lint_check_'
-    }.each { |method|
-      name = method.to_s[11..-1]
-      @default_info[:check] = name
-      self.send(method) if PuppetLint.configuration.send("#{name}_enabled?")
-    }
+    enabled_checks.each do |check|
+      @default_info[:check] = check
+      self.send("lint_check_#{check}")
+    end
 
     @problems
   end
 
-  def tokens
-    @tokens
+  def enabled_checks
+    @enabled_checks ||= Proc.new do
+      self.public_methods.select { |method|
+        method.to_s.start_with? 'lint_check_'
+      }.map { |method|
+        method.to_s[11..-1]
+      }.select { |name|
+        PuppetLint.configuration.send("#{name}_enabled?")
+      }
+    end.call
   end
 
-  def path
-    @fileinfo[:path]
+  def tokens
+    @tokens
   end
 
   def fullpath
     @fileinfo[:fullpath]
   end
 
-  def data
-    @data
-  end
-
   def title_tokens
     @title_tokens ||= Proc.new do
       result = []
@@ -98,10 +94,11 @@ class PuppetLint::CheckPlugin
             }
             title_array_tokens = tokens[(array_start_idx + 1)..(token_idx - 2)]
             result += title_array_tokens.select { |token|
-              [:STRING, :NAME].include? token.type
+              {:STRING => true, :NAME => true}.include? token.type
             }
           else
-            if tokens[token_idx + 1].type != :LBRACE
+            next_token = tokens[token_idx].next_code_token
+            if next_token.type != :LBRACE
               result << tokens[token_idx - 1]
             end
           end
@@ -126,15 +123,23 @@ class PuppetLint::CheckPlugin
       result = []
       tokens.each_index do |token_idx|
         if tokens[token_idx].type == :COLON
-          next_tokens = tokens[(token_idx + 1)..-1].reject { |r|
-            formatting_tokens.include? r.type
-          }
-          if next_tokens.first.type != :LBRACE
-            end_idx = tokens[(token_idx + 1)..-1].index { |r|
-              [:SEMIC, :RBRACE].include? r.type
-            } + token_idx
-
-            result << {:start => token_idx + 1, :end => end_idx}
+          next_token = tokens[token_idx].next_code_token
+          depth = 1
+          if next_token.type != :LBRACE
+            tokens[(token_idx + 1)..-1].each_index do |idx|
+              real_idx = token_idx + idx + 1
+              if tokens[real_idx].type == :LBRACE
+                depth += 1
+              elsif {:SEMIC => true, :RBRACE => true}.include? tokens[real_idx].type
+                unless tokens[real_idx].type == :SEMIC && depth > 1
+                  depth -= 1
+                  if depth == 0
+                    result << {:start => token_idx + 1, :end => real_idx}
+                    break
+                  end
+                end
+              end
+            end
           end
         end
       end
@@ -156,16 +161,19 @@ class PuppetLint::CheckPlugin
       tokens.each_index do |token_idx|
         if tokens[token_idx].type == :CLASS
           depth = 0
+          in_params = false
           tokens[token_idx+1..-1].each_index do |class_token_idx|
             idx = class_token_idx + token_idx + 1
-            if tokens[idx].type == :LBRACE
-              depth += 1
+            if tokens[idx].type == :LPAREN
+              in_params = true
+            elsif tokens[idx].type == :RPAREN
+              in_params = false
+            elsif tokens[idx].type == :LBRACE
+              depth += 1 unless in_params
             elsif tokens[idx].type == :RBRACE
-              depth -= 1
-              if depth == 0
-                if tokens[token_idx..-1].reject { |r|
-                  r.type == :WHITESPACE
-                }[1].type != :LBRACE
+              depth -= 1 unless in_params
+              if depth == 0 && ! in_params
+                if tokens[token_idx].next_code_token.type != :LBRACE
                   result << {:start => token_idx, :end => idx}
                 end
                 break
@@ -192,13 +200,18 @@ class PuppetLint::CheckPlugin
       tokens.each_index do |token_idx|
         if tokens[token_idx].type == :DEFINE
           depth = 0
+          in_params = false
           tokens[token_idx+1..-1].each_index do |define_token_idx|
             idx = define_token_idx + token_idx + 1
-            if tokens[idx].type == :LBRACE
-              depth += 1
+            if tokens[idx].type == :LPAREN
+              in_params = true
+            elsif tokens[idx].type == :RPAREN
+              in_params = false
+            elsif tokens[idx].type == :LBRACE
+              depth += 1 unless in_params
             elsif tokens[idx].type == :RBRACE
-              depth -= 1
-              if depth == 0
+              depth -= 1 unless in_params
+              if depth == 0 && ! in_params
                 result << {:start => token_idx, :end => idx}
                 break
               end
@@ -211,14 +224,7 @@ class PuppetLint::CheckPlugin
   end
 
   def formatting_tokens
-    [
-      :COMMENT,
-      :MLCOMMENT,
-      :SLASH_COMENT,
-      :INDENT,
-      :WHITESPACE,
-      :NEWLINE,
-    ]
+    @formatting_tokens ||= PuppetLint::Lexer::FORMATTING_TOKENS
   end
 
   def manifest_lines

data/lib/puppet-lint/plugins.rb

@@ -4,7 +4,9 @@ class PuppetLint
 end
 
 require 'puppet-lint/plugins/check_classes'
+require 'puppet-lint/plugins/check_comments'
 require 'puppet-lint/plugins/check_conditionals'
+require 'puppet-lint/plugins/check_documentation'
 require 'puppet-lint/plugins/check_strings'
 require 'puppet-lint/plugins/check_variables'
 require 'puppet-lint/plugins/check_whitespace'

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

@@ -42,40 +42,153 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
     end
   end
 
+  # Public: Check the manifest tokens for any classes or defined types that
+  # have a dash in their name and record a warning for each instance found.
+  #
+  # Returns nothing.
+  check 'names_containing_dash' do
+    (class_indexes + defined_type_indexes).each do |class_idx|
+      class_tokens = tokens[class_idx[:start]..class_idx[:end]]
+      title_token = class_tokens[class_tokens.index { |r| r.type == :NAME }]
+
+      if title_token.value.include? '-'
+        if class_tokens.first.type == :CLASS
+          obj_type = 'class'
+        else
+          obj_type = 'defined type'
+        end
+
+        notify :warning, {
+          :message    => "#{obj_type} name containing a dash",
+          :linenumber => title_token.line,
+          :column     => title_token.column,
+        }
+      end
+    end
+  end
+
+  check 'parameterised_classes' do
+    class_indexes.each do |class_idx|
+      token_idx = class_idx[:start]
+      depth = 0
+      lparen_idx = nil
+      rparen_idx = nil
+      tokens[token_idx..-1].each_index do |t|
+        idx = token_idx + t
+        if tokens[idx].type == :LPAREN
+          depth += 1
+          lparen_idx = idx if depth == 1
+        elsif tokens[idx].type == :RPAREN
+          depth -= 1
+          if depth == 0
+            rparen_idx = idx
+            break
+          end
+        end
+      end
+
+      class_tokens = tokens[class_idx[:start]..class_idx[:end]].reject { |r|
+        formatting_tokens.include? r.type
+      }
+      inherits_idx = class_tokens.index { |r| r.type == :INHERITS }
+      unless inherits_idx.nil?
+        inherited_class_token = class_tokens[inherits_idx + 1]
+        if inherited_class_token.value.end_with? '::params'
+          notify :warning, {
+            :message    => 'class inheriting from params class',
+            :linenumber => inherited_class_token.line,
+            :column     => inherited_class_token.column,
+          }
+        end
+      end
+
+      unless lparen_idx.nil? or rparen_idx.nil?
+        param_tokens = tokens[lparen_idx+1..rparen_idx-1].reject { |r|
+          formatting_tokens.include? r.type
+        }
+
+        paren_stack = []
+        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.type == :LPAREN
+            paren_stack.push(true)
+          elsif this_token.type == :RPAREN
+            paren_stack.pop
+          end
+          next unless paren_stack.empty?
+
+          if this_token.type == :VARIABLE
+            if !next_token.nil? && next_token.type != :EQUALS
+              if !prev_token.nil? && prev_token.type != :EQUALS
+                notify :warning, {
+                  :message    => 'parameterised class parameter without a default value',
+                  :linenumber => this_token.line,
+                  :column     => this_token.column,
+                }
+              end
+            end
+          end
+        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|
+    defined_type_indexes.each do |class_idx|
       token_idx = class_idx[:start]
-      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 }
+      depth = 0
+      lparen_idx = nil
+      rparen_idx = nil
+      tokens[token_idx..-1].each_index do |t|
+        idx = token_idx + t
+        if tokens[idx].type == :LPAREN
+          depth += 1
+          lparen_idx = idx if depth == 1
+        elsif tokens[idx].type == :RPAREN
+          depth -= 1
+          if depth == 0
+            rparen_idx = idx
+            break
+          end
+        end
+      end
 
       unless lparen_idx.nil? or rparen_idx.nil?
-        param_tokens = header_tokens[lparen_idx..rparen_idx]
+        param_tokens = tokens[lparen_idx+1..rparen_idx-1].reject { |r|
+          formatting_tokens.include? r.type
+        }
+
+        paren_stack = []
         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.type == :LPAREN
+            paren_stack.push(true)
+          elsif this_token.type == :RPAREN
+            paren_stack.pop
+          end
+          next unless paren_stack.empty?
+
           if this_token.type == :VARIABLE
-            unless next_token.nil?
-              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
+            if next_token.nil? || next_token.type == :COMMA
+              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
@@ -91,19 +204,19 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
   # Returns nothing.
   check 'inherits_across_namespaces' do
     class_indexes.each do |class_idx|
-      class_tokens = tokens[class_idx[:start]..class_idx[:end]].reject { |r|
-        formatting_tokens.include?(r.type)
-      }
+      class_token = tokens[class_idx[:start]]
+      class_name_token = class_token.next_code_token
+      inherits_token = class_name_token.next_code_token
+      next if inherits_token.nil?
 
-      if class_tokens[2].type == :INHERITS
-        class_name = class_tokens[1].value
-        inherited_class = class_tokens[3].value
+      if inherits_token.type == :INHERITS
+        inherited_class_token = inherits_token.next_code_token
 
-        unless class_name =~ /^#{inherited_class}::/
+        unless class_name_token.value =~ /^#{inherited_class_token.value}::/
           notify :warning, {
             :message    => "class inherits across namespaces",
-            :linenumber => class_tokens[3].line,
-            :column     => class_tokens[3].column,
+            :linenumber => inherited_class_token.line,
+            :column     => inherited_class_token.column,
           }
         end
       end
@@ -117,16 +230,11 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
   check 'nested_classes_or_defines' do
     class_indexes.each do |class_idx|
       # 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]
+      class_tokens = tokens[class_idx[:start]+1..class_idx[:end]]
 
+      class_tokens.each do |token|
         if token.type == :CLASS
-          if next_token.type != :LBRACE
+          if token.next_code_token.type != :LBRACE
             notify :warning, {
               :message    => "class defined inside a class",
               :linenumber => token.line,
@@ -169,14 +277,22 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
     (class_indexes + defined_type_indexes).each do |idx|
       object_tokens = tokens[idx[:start]..idx[:end]]
       object_tokens.reject! { |r| formatting_tokens.include?(r.type) }
+      depth = 0
+      lparen_idx = nil
+      rparen_idx = nil
+      object_tokens.each_index do |t|
+        if object_tokens[t].type == :LPAREN
+          depth += 1
+          lparen_idx = t if depth == 1
+        elsif object_tokens[t].type == :RPAREN
+          depth -= 1
+          if depth == 0
+            rparen_idx = t
+            break
+          end
+        end
+      end
       referenced_variables = []
-      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]
@@ -184,7 +300,7 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
           this_token = param_tokens[param_tokens_idx]
           next_token = param_tokens[param_tokens_idx+1]
           if this_token.type == :VARIABLE
-            if [:COMMA, :EQUALS, :RPAREN].include? next_token.type
+            if {:COMMA => true, :EQUALS => true, :RPAREN => true}.include? next_token.type
               variables_in_scope << this_token.value
             end
           end