puppet-lint 0.1.9 → 0.1.10

data/Rakefile

@@ -2,5 +2,24 @@ require 'rake'
 require 'rspec/core/rake_task'
 
 task :default => :test
+#task :default => [:test, :rdoc]
 
 RSpec::Core::RakeTask.new(:test)
+
+### RDOC Tasks ###
+require 'rdoc'
+if (RDoc::VERSION.split('.') <=> ['2','4','2']) >= 0
+  require 'rdoc/task'
+  RDoc::Task.new(:rdoc) do |rdoc|
+    rdoc.main = "README.md"
+    rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+    rdoc.options << "--all"
+  end
+else
+  require 'rake/rdoctask'
+  Rake::RDocTask.new(:rdoc) do |rdoc|
+    rdoc.main = "README.md"
+    rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+    rdoc.options << "--all"
+  end
+end

data/bin/puppet-lint

@@ -17,10 +17,6 @@ require 'optparse'
 require 'rubygems'
 require 'puppet-lint'
 
-options = {
-  :error_level   => :all,
-  :with_filename => false,
-}
 opts = OptionParser.new do |opts|
   opts.banner = help
 
@@ -30,19 +26,45 @@ opts = OptionParser.new do |opts|
   end
 
   opts.on("--with-filename", "Display the filename before the warning") do
-    options[:with_filename] = true
+    PuppetLint.configuration.with_filename = true
   end
 
-  opts.on("--error-level LEVEL", [:all, :warning, :error], "The level of error to return (warning, error, all).") do |el|
-    options[:error_level] = el
+  opts.on("--error-level LEVEL", [:all, :warning, :error], "The level of error to return.", "(warning, error, all)") do |el|
+    PuppetLint.configuration.error_level = el
   end
 
   opts.on("--fail-on-warnings", "Return a non-zero exit status for warnings.") do
-    options[:fail_on_warnings] = true
+    PuppetLint.configuration.fail_on_warnings = true
   end
+
+  opts.on("--log-format FORMAT",
+    "Change the log format.", "Overrides --with-filename.",
+    "The following placeholders can be used:",
+    "%{filename}   - Filename without path.",
+    "%{path}       - Path as provided.",
+    "%{fullpath}   - Full path.",
+    "%{linenumber} - Line number.",
+    "%{kind}       - The kind of message.",
+    "              - (warning, error)",
+    "%{KIND}       - Uppercase version of %{kind}",
+    "%{check}      - Name of the check.",
+    "%{message}    - The message."
+  ) do |format|
+    PuppetLint.configuration.log_format = format
+  end
+
+  opts.separator ""
+  opts.separator "    Disable checks:"
+
+  PuppetLint.configuration.checks.each do |check|
+    opts.on("--no-#{check}-check", "Skip the #{check} check") do
+      PuppetLint.configuration.send("disable_#{check}")
+    end
+  end
+
+  opts.load(File.expand_path("~/.puppet-lintrc")) unless opts.load(".puppet-lintrc")
 end
 
-# Read command line options into `options` hash
 begin
   opts.parse!
 rescue OptionParser::InvalidOption
@@ -58,11 +80,11 @@ if ARGV[0].nil?
 end
 
 begin
-  l = PuppetLint.new(options)
+  l = PuppetLint.new
   l.file = ARGV[0]
   l.run
 
-  if l.errors? or (l.warnings? and options[:fail_on_warnings])
+  if l.errors? or (l.warnings? and PuppetLint.configuration.fail_on_warnings)
     exit 1
   end
 rescue PuppetLint::NoCodeError

data/lib/puppet-lint.rb

@@ -7,8 +7,8 @@ rescue LoadError
   exit 1
 end
 
+require 'puppet-lint/configuration'
 require 'puppet-lint/plugin'
-require 'puppet-lint/plugins'
 
 unless String.respond_to?('prepend')
   class String
@@ -18,25 +18,85 @@ unless String.respond_to?('prepend')
   end
 end
 
+# If we are using an older ruby version, we back-port the basic functionality
+# we need for formatting output: 'somestring' % <hash>
+begin
+  if ('%{test}' % {:test => 'replaced'} == 'replaced')
+    # If this works, we are all good to go.
+  end
+rescue
+  # If the test failed (threw a error), monkeypatch String.
+  # Most of this code came from http://www.ruby-forum.com/topic/144310 but was
+  # simplified for our use.
+
+  # Basic implementation of 'string' % { } like we need it. needs work.
+  class String
+    Percent = instance_method '%' unless defined? Percent
+    def % *a, &b
+      a.flatten!
+
+      string = case a.last
+      when Hash
+        expand a.pop
+      else
+        self
+      end
+
+      if a.empty?
+        string
+      else
+        Percent.bind(string).call(*a, &b)
+      end
+
+    end
+    def expand! vars = {}
+      loop do
+        changed = false
+        vars.each do |var, value|
+          var = var.to_s
+          var.gsub! %r/[^a-zA-Z0-9_]/, ''
+          [
+            %r/\%\{#{ var }\}/,
+          ].each do |pat|
+            changed = gsub! pat, "#{ value }"
+          end
+        end
+        break unless changed
+      end
+      self
+    end
+    def expand opts = {}
+      dup.expand! opts
+    end
+  end
+end
+
 class PuppetLint::NoCodeError < StandardError; end
 
 class PuppetLint
-  VERSION = '0.1.9'
+  VERSION = '0.1.10'
 
   attr_reader :code, :file
 
-  def initialize(options)
+  def initialize
     @data = nil
-    @errors = 0
-    @warnings = 0
-    @with_filename = options[:with_filename]
-    @path = ''
-    @error_level = options[:error_level]
+    @statistics = {:error => 0, :warning => 0}
+    @fileinfo = {:path => ''}
+  end
+
+  def self.configuration
+    @configuration ||= PuppetLint::Configuration.new
+  end
+
+  def configuration
+    self.class.configuration
   end
 
   def file=(path)
     if File.exist? path
-      @path = File.expand_path(path)
+      @fileinfo[:path] = path
+      @fileinfo[:fullpath] = File.expand_path(path)
+      @fileinfo[:filename] = File.basename(path)
       @data = File.read(path)
     end
   end
@@ -45,27 +105,48 @@ class PuppetLint
     @data = value
   end
 
-  def report(kind, message)
-    #msg = message
-    if kind == :warnings
-      @warnings += 1
-      message.prepend('WARNING: ')
-    else
-      @errors += 1
-      message.prepend('ERROR: ')
-    end
-    if @with_filename
-      message.prepend("#{@path} - ")
+  def log_format
+    if configuration.log_format == ''
+      ## recreate previous old log format as far as thats possible.
+      format = '%{KIND}: %{message} on line %{linenumber}'
+      if configuration.with_filename
+        format.prepend '%{path} - '
+      end
+      configuration.log_format = format
     end
-    puts message
+    return configuration.log_format
+  end
+
+  def format_message(message)
+    format = log_format
+    puts format % message
   end
 
+  def report(problems)
+    problems.each do |message|
+      @statistics[message[:kind]] += 1
+      ## Add some default attributes.
+      message.merge!(@fileinfo) {|key, v1, v2| v1 }
+      message[:KIND] = message[:kind].to_s.upcase
+
+      if configuration.error_level == message[:kind] or configuration.error_level == :all
+        format_message message
+      end
+    end
+  end
+  
   def errors?
-    @errors != 0
+    @statistics[:error] != 0
   end
 
   def warnings?
-    @warnings != 0
+    @statistics[:warning] != 0
+  end
+
+  def checks
+    PuppetLint::CheckPlugin.repository.map do |plugin|
+      plugin.new.checks
+    end.flatten
   end
 
   def run
@@ -74,17 +155,15 @@ class PuppetLint
     end
 
     PuppetLint::CheckPlugin.repository.each do |plugin|
-      problems = plugin.new.run(@path, @data)
-      case @error_level
-      when :warning
-        problems[:warnings].each { |warning| report :warnings, warning }
-      when :error
-        problems[:errors].each { |error| report :errors, error }
-      else
-        problems[:warnings].each { |warning| report :warnings, warning }
-        problems[:errors].each { |error| report :errors, error }
-      end
+      report plugin.new.run(@fileinfo[:path], @data)
     end
   end
 end
 
+# Default configuration options
+PuppetLint.configuration.fail_on_warnings = false
+PuppetLint.configuration.error_level = :all
+PuppetLint.configuration.with_filename = false
+PuppetLint.configuration.log_format = ''
+
+require 'puppet-lint/plugins'

data/lib/puppet-lint/configuration.rb

@@ -0,0 +1,57 @@
+class PuppetLint
+  class Configuration
+    def self.add_check(check)
+      define_method("#{check}_enabled?") do
+        settings["#{check}_disabled"] == true ? false : true
+      end
+
+      define_method("disable_#{check}") do
+        settings["#{check}_disabled"] = true
+      end
+
+      define_method("enable_#{check}") do
+        settings["#{check}_disabled"] = false
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /^(\w+)=$/
+        option = $1
+        add_option(option.to_s) if settings[option].nil?
+        settings[option] = args[0]
+      else
+        nil
+      end
+    end
+
+    def add_option(option)
+      self.class.add_option(option)
+    end
+
+    def self.add_option(option)
+      define_method("#{option}=") do |value|
+        settings[option] = value
+      end
+
+      define_method(option) do
+        settings[option]
+      end
+    end
+
+    def add_check(check)
+      self.class.add_check(check)
+    end
+
+    def settings
+      @settings ||= {}
+    end
+
+    def checks
+      self.public_methods.select { |method|
+        method =~ /^.+_enabled\?$/
+      }.map { |method|
+        method[0..-10]
+      }
+    end
+  end
+end

data/lib/puppet-lint/plugin.rb

@@ -1,4 +1,5 @@
 class PuppetLint
+
   module Plugin
     module ClassMethods
       def repository
@@ -18,29 +19,139 @@ end
 
 class PuppetLint::CheckPlugin
   include PuppetLint::Plugin
-  attr_reader :warnings, :errors
+  attr_reader :problems, :checks
 
   def initialize
-    @warnings = []
-    @errors = []
+    @problems = []
+    @checks = []
+    @default_info = {:check => 'unknown', :linenumber => 0}
   end
 
-  def warn(message)
-    @warnings << message
+  def register_check(check)
+    @checks << check
   end
 
-  def error(message)
-    @errors << message
+  #     notify(kind, message_hash)    #=> nil
+  #
+  # Adds the message to the problems array.
+  # The _kind_ gets added to the _message_hash_ by setting the key :_kind_.
+  # Typically, the _message_hash_ should contain following keys:
+  # <i>message</i>::     which contains a string value describing the problem
+  # <i>linenumber</i>::  which contains the line number on which the problem occurs.
+  # Besides the :_kind_ value that is being set, some other key/values are also
+  # added. Typically, this is
+  # <i>check</i>::      which contains the name of the check that is being executed.
+  # <i>linenumber</i>:: which defaults to 0 if the message does not already contain one.
+  #
+  #     notify :warning, :message => "Something happened", :linenumber => 4
+  #     => {:kind=>:warning, :message=>"Something happened", :linenumber=>4, :check=>'unknown'}
+  #
+  def notify(kind, message_hash)
+    message_hash[:kind] = kind
+    message_hash.merge!(@default_info) {|key, v1, v2| v1 }
+    @problems << message_hash
+    message_hash
   end
 
   def run(path, data)
-    test(path, data)
+    lexer = Puppet::Parser::Lexer.new
+    lexer.string = data
+    @tokens = lexer.fullscan
+    @path = path
+    @data = data
+
+    test(path, data) if self.respond_to? :test
+    self.public_methods.select { |method|
+      method.start_with? 'lint_check_'
+    }.each { |method|
+      name = method[11..-1]
+      @default_info[:check] = name
+      self.send(method) if PuppetLint.configuration.send("#{name}_enabled?")
+    }
+
+    @problems
+  end
+
+  def filter_tokens
+    @title_tokens = []
+    @resource_indexes = []
+    @class_indexes = []
+    @defined_type_indexes = []
+
+    @tokens.each_index do |token_idx|
+      if @tokens[token_idx].first == :COLON
+        # gather a list of tokens that are resource titles
+        if @tokens[token_idx-1].first == :RBRACK
+          title_array_tokens = @tokens[@tokens.rindex { |r| r.first == :LBRACK }+1..token_idx-2]
+          @title_tokens += title_array_tokens.select { |token| [:STRING, :NAME].include? token.first }
+        else
+          if @tokens[token_idx + 1].first != :LBRACE
+            @title_tokens << @tokens[token_idx-1]
+          end
+        end
+
+        # 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
+      elsif [:CLASS, :DEFINE].include? @tokens[token_idx].first
+        lbrace_count = 0
+        @tokens[token_idx+1..-1].each_index do |class_token_idx|
+          idx = class_token_idx + token_idx
+          if @tokens[idx].first == :LBRACE
+            lbrace_count += 1
+          elsif @tokens[idx].first == :RBRACE
+            lbrace_count -= 1
+            if lbrace_count == 0
+              class_indexes << {:start => token_idx, :end => idx} if @tokens[token_idx].first == :CLASS
+              defined_type_indexes << {:start => token_idx, :end => idx} if @tokens[token_idx].first == :DEFINE
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def tokens
+    @tokens
+  end
+
+  def path
+    @path
+  end
+
+  def data
+    @data
+  end
+
+  def title_tokens
+    filter_tokens if @title_tokens.nil?
+    @title_tokens
+  end
+
+  def resource_indexes
+    filter_tokens if @resource_indexes.nil?
+    @resource_indexes
+  end
+
+  def class_indexes
+    filter_tokens if @class_indexes.nil?
+    @class_indexes
+  end
+
+  def defined_type_indexes
+    filter_tokens if @defined_type_indexes.nil?
+    @defined_type_indexes
+  end
 
-    {:warnings => @warnings, :errors => @errors}
+  def manifest_lines
+    @manifest_lines ||= @data.split("\n")
   end
 
-  def test(data)
-    raise NotImplementedError.new "Oh no"
+  def self.check(name, &b)
+    PuppetLint.configuration.add_check name
+    define_method("lint_check_#{name}", b)
   end
 end