puppet-lint 0.4.0.pre1 → 1.0.0

data/lib/puppet-lint/checkplugin.rb

@@ -1,22 +1,168 @@
+# Public: A class that contains and provides information for the puppet-lint
+# checks.
+#
+# This class should not be used directly, but instead should be inherited.
+#
+# Examples
+#
+#   class PuppetLint::Plugin::CheckFoo < PuppetLint::CheckPlugin
+#   end
 class PuppetLint::CheckPlugin
-  # Public: Define a new lint check.
+  # Internal: Initialise a new PuppetLint::CheckPlugin.
+  def initialize
+    @problems = []
+  end
+
+  # Internal: Check the manifest for problems and filter out any problems that
+  # should be ignored.
+  #
+  # Returns an Array of problem Hashes.
+  def run
+    check
+
+    @problems.each do |problem|
+      if PuppetLint::Data.ignore_overrides[problem[:check]].has_key?(problem[:line])
+        problem[:kind] = :ignored
+        problem[:reason] = PuppetLint::Data.ignore_overrides[problem[:check]][problem[:line]]
+        next
+      end
+    end
+
+    @problems
+  end
+
+  # Internal: Fix any problems the check plugin has detected.
   #
-  # name - The String name of the check.
-  # b    - The Block implementation of the check.
+  # Returns an Array of problem Hashes.
+  def fix_problems
+    @problems.each do |problem|
+      if self.respond_to?(:fix)
+        begin
+          fix(problem)
+        rescue PuppetLint::NoFix
+          # noop
+        else
+          problem[:kind] = :fixed
+        end
+      end
+    end
+
+    @problems
+  end
+
+  private
+
+  # Public: Provides the tokenised manifest to the check plugins.
   #
-  # Returns nothing.
-  def self.check(name, &b)
-    PuppetLint.configuration.add_check(name, &b)
+  # Returns an Array of PuppetLint::Lexer::Token objects.
+  def tokens
+    PuppetLint::Data.tokens
+  end
+
+  # Public: Provides the resource titles to the check plugins.
+  #
+  # Returns an Array of PuppetLint::Lexer::Token objects.
+  def title_tokens
+    PuppetLint::Data.title_tokens
+  end
+
+  # Public: Provides positional information for any resource declarations in
+  # the tokens array to the check plugins.
+  #
+  # Returns an Array of Hashes containing the position information.
+  def resource_indexes
+    PuppetLint::Data.resource_indexes
+  end
+
+  # Public: Provides positional information for any class definitions in the
+  # tokens array to the check plugins.
+  #
+  # Returns an Array of Hashes containing the position information.
+  def class_indexes
+    PuppetLint::Data.class_indexes
+  end
+
+  # Public: Provides positional information for any defined type definitions in
+  # the tokens array to the check plugins.
+  #
+  # Returns an Array of Hashes containing the position information.
+  def defined_type_indexes
+    PuppetLint::Data.defined_type_indexes
+  end
+
+  # Public: Provides the expanded path of the file being analysed to check
+  # plugins.
+  #
+  # Returns the String path.
+  def fullpath
+    PuppetLint::Data.fullpath
+  end
+
+  # Public: Provides the path of the file being analysed as it was provided to
+  # puppet-lint to the check plugins.
+  #
+  # Returns the String path.
+  def path
+    PuppetLint::Data.path
+  end
+
+  # Public: Provides the name of the file being analysed to the check plugins.
+  #
+  # Returns the String file name.
+  def filename
+    PuppetLint::Data.filename
   end
 
-  # Public: Define a new check helper method.
+  # Public: Provides a list of formatting tokens to the check plugins.
   #
-  # name - The String name of the helper.
-  # b    - The Block implementation of the helper.
+  # Returns an Array of Symbol token types.
+  def formatting_tokens
+    PuppetLint::Data.formatting_tokens
+  end
+
+  # Public: Provides a list of manifest lines to the check plugins.
+  #
+  # Returns an Array of manifest lines.
+  def manifest_lines
+    PuppetLint::Data.manifest_lines
+  end
+
+  # Internal: Prepare default problem report information.
+  #
+  # Returns a Hash of default problem information.
+  def default_info
+    @default_info ||= {
+      :check      => self.class.const_get('NAME'),
+      :fullpath   => fullpath,
+      :path       => path,
+      :filename   => filename,
+    }
+  end
+
+  # Public: Report a problem with the manifest being checked.
+  #
+  # kind    - The Symbol problem type (:warning or :error).
+  # problem - A Hash containing the attributes of the problem
+  #   :message - The String message describing the problem.
+  #   :line    - The Integer line number of the location of the problem.
+  #   :column  - The Integer column number of the location of the problem.
+  #   :check   - The Symbol name of the check that detected the problem.
   #
   # Returns nothing.
-  def self.helper(name, &b)
-    PuppetLint.configuration.add_helper(name, &b)
+  def notify(kind, problem)
+    problem[:kind] = kind
+    problem.merge!(default_info) { |key, v1, v2| v1 }
+
+    unless [:warning, :error, :fixed].include? kind
+      raise ArgumentError, "unknown value passed for kind"
+    end
+
+    [:message, :line, :column, :check].each do |attr|
+      unless problem.has_key? attr
+        raise ArgumentError, "problem hash must contain #{attr.inspect}"
+      end
+    end
+
+    @problems << problem
   end
 end
-

data/lib/puppet-lint/checks.rb

@@ -1,69 +1,42 @@
 require 'puppet-lint/checkplugin'
 
+# Internal: Various methods that orchestrate the actions of the puppet-lint
+# check plugins.
 class PuppetLint::Checks
   # Public: Get an Array of problem Hashes.
-  attr_reader :problems
+  attr_accessor :problems
 
-  # Public: Get an Array of PuppetLint::Lexer::Token objects.
-  attr_reader :tokens
-
-  # Public: Initialise a new PuppetLint::Checks object and prepare the check
-  # methods.
+  # Public: Initialise a new PuppetLint::Checks object.
   def initialize
     @problems = []
-    @default_info = {:check => 'unknown', :linenumber => 0, :column => 0}
-
-    PuppetLint.configuration.checks.each do |check|
-      method = PuppetLint.configuration.check_method[check]
-      self.class.send(:define_method, "lint_check_#{check}", &method)
-    end
-
-    PuppetLint.configuration.helpers.each do |helper|
-      method = PuppetLint.configuration.helper_method[helper]
-      self.class.send(:define_method, helper, &method)
-    end
-  end
-
-  # Public: Add a message to the problems array.
-  #
-  # kind    - The kind of problem as a Symbol (:warning, :error).
-  # problem - A Hash containing the attributes of the problem.
-  #   :message    - The String message describing the problem.
-  #   :linenumber - The Integer line number of the location of the problem.
-  #   :check      - The String name of the check that the problem came from.
-  #   :column     - The Integer column number of the location of the problem.
-  #
-  # Returns nothing.
-  def notify(kind, problem)
-    problem[:kind] = kind
-    problem.merge!(@default_info) {|key, v1, v2| v1 }
-    @problems << problem
   end
 
   # Internal: Tokenise the manifest code and prepare it for checking.
   #
-  # fileinfo - A Hash containing the following:
-  #   :fullpath - The expanded path to the file as a String.
-  #   :filename - The name of the file as a String.
-  #   :path     - The original path to the file as passed to puppet-lint as
-  #               a String.
-  # data     - The String manifest code to be checked.
+  # path    - The path to the file as passed to puppet-lint as a String.
+  # content - The String manifest code to be checked.
   #
   # Returns nothing.
-  def load_data(fileinfo, data)
+  def load_data(path, content)
     lexer = PuppetLint::Lexer.new
+    PuppetLint::Data.path = path
+    PuppetLint::Data.manifest_lines = content.split("\n")
     begin
-      @tokens = lexer.tokenise(data)
+      PuppetLint::Data.tokens = lexer.tokenise(content)
+      PuppetLint::Data.parse_control_comments
     rescue PuppetLint::LexerError => e
-      notify :error, {
-        :message => 'Syntax error (try running `puppet parser validate <file>`)',
-        :linenumber => e.line_no,
-        :column => e.column,
+      problems << {
+        :kind     => :error,
+        :check    => :syntax,
+        :message  => 'Syntax error (try running `puppet parser validate <file>`)',
+        :line     => e.line_no,
+        :column   => e.column,
+        :fullpath => PuppetLint::Data.fullpath,
+        :path     => PuppetLint::Data.path,
+        :filename => PuppetLint::Data.filename,
       }
-      @tokens = []
+      PuppetLint::Data.tokens = []
     end
-    @fileinfo = fileinfo
-    @data = data
   end
 
   # Internal: Run the lint checks over the manifest code.
@@ -79,9 +52,20 @@ class PuppetLint::Checks
   def run(fileinfo, data)
     load_data(fileinfo, data)
 
+    checks_run = []
     enabled_checks.each do |check|
-      @default_info[:check] = check
-      self.send("lint_check_#{check}")
+      klass = PuppetLint.configuration.check_object[check].new
+      problems = klass.run
+
+      if PuppetLint.configuration.fix
+        checks_run << klass
+      else
+        @problems.concat(problems)
+      end
+    end
+
+    checks_run.each do |check|
+      @problems.concat(check.fix_problems)
     end
 
     @problems
@@ -92,183 +76,16 @@ class PuppetLint::Checks
   # Returns an Array of String check names.
   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?")
+      PuppetLint.configuration.checks.select { |check|
+        PuppetLint.configuration.send("#{check}_enabled?")
       }
     end.call
   end
 
-  # Public: Get the full expanded path to the file being checked.
-  #
-  # Returns a String path.
-  def fullpath
-    @fileinfo[:fullpath]
-  end
-
-  # Public: Retrieve a list of tokens that represent resource titles.
-  #
-  # Returns an Array of PuppetLint::Lexer::Token objects.
-  def title_tokens
-    @title_tokens ||= Proc.new do
-      result = []
-      tokens.each_index do |token_idx|
-        if tokens[token_idx].type == :COLON
-          # gather a list of tokens that are resource titles
-          if tokens[token_idx-1].type == :RBRACK
-            array_start_idx = tokens.rindex { |r|
-              r.type == :LBRACK
-            }
-            title_array_tokens = tokens[(array_start_idx + 1)..(token_idx - 2)]
-            result += title_array_tokens.select { |token|
-              {:STRING => true, :NAME => true}.include? token.type
-            }
-          else
-            next_token = tokens[token_idx].next_code_token
-            if next_token.type != :LBRACE
-              result << tokens[token_idx - 1]
-            end
-          end
-        end
-      end
-      result
-    end.call
-  end
-
-  # Public: Calculate the positions of all resource declarations within the
-  # tokenised manifest.  These positions only point to the content of the
-  # resource declaration, they do not include resource types or
-  # titles/namevars.
-  #
-  # Returns an Array of Hashes, each containing:
-  #   :start - An Integer position in the `tokens` Array pointing to the first
-  #            Token of a resource declaration parameters (type :NAME).
-  #   :end   - An Integer position in the `tokens` Array pointing to the last
-  #            Token of a resource declaration parameters (type :RBRACE).
-  def resource_indexes
-    @resource_indexes ||= Proc.new do
-      result = []
-      tokens.each_index do |token_idx|
-        if tokens[token_idx].type == :COLON
-          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
-      result
-    end.call
-  end
-
-  # Public: Calculate the positions of all class definitions within the
-  # tokenised manifest.
-  #
-  # Returns an Array of Hashes, each containing:
-  #   :start - An Integer position in the `tokens` Array pointing to the first
-  #            token of a class (type :CLASS).
-  #   :end   - An Integer position in the `tokens` Array pointing to the last
-  #            token of a class (type :RBRACE).
-  def class_indexes
-    @class_indexes ||= Proc.new do
-      result = []
-      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 == :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 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
-              end
-            end
-          end
-        end
-      end
-      result
-    end.call
-  end
-
-  # Public: Calculate the positions of all defined type definitions within
-  # the tokenised manifest.
-  #
-  # Returns an Array of Hashes, each containing:
-  #   :start - An Integer position in the `tokens` Array pointing to the first
-  #            token of a defined type (type :DEFINE).
-  #   :end   - An Integer position in the `tokens` Array pointing to the last
-  #            token of a defined type (type :RBRACE).
-  def defined_type_indexes
-    @defined_type_indexes ||= Proc.new do
-      result = []
-      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 == :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 unless in_params
-              if depth == 0 && ! in_params
-                result << {:start => token_idx, :end => idx}
-                break
-              end
-            end
-          end
-        end
-      end
-      result
-    end.call
-  end
-
-  # Public: Retrieves a list of token types that are considered to be
-  # formatting tokens (ie whitespace, newlines, etc).
-  #
-  # Returns an Array of Symbols.
-  def formatting_tokens
-    @formatting_tokens ||= PuppetLint::Lexer::FORMATTING_TOKENS
-  end
-
-  # Public: Access the lines of the manifest that is being checked.
+  # Internal: Render the fixed manifest.
   #
-  # Returns an Array of Strings.
-  def manifest_lines
-    @manifest_lines ||= @data.split("\n")
-  end
-
+  # Returns the manifest as a String.
   def manifest
-    tokens.map { |t| t.to_manifest }.join('')
+    PuppetLint::Data.tokens.map { |t| t.to_manifest }.join('')
   end
 end