puppet-lint 0.3.2 → 0.4.0.pre1

data/lib/puppet-lint/monkeypatches/string_prepend.rb

@@ -0,0 +1,7 @@
+unless String.respond_to?('prepend')
+  class String
+    def prepend(lead)
+      self.replace "#{lead}#{self}"
+    end
+  end
+end

data/lib/puppet-lint/plugins.rb

@@ -1,5 +1,45 @@
+require 'pathname'
+
 class PuppetLint
   class Plugins
+    # Public: Find any gems containing puppet-lint plugins and load them.
+    #
+    # Returns nothing.
+    def self.load_from_gems
+      gem_directories.select { |path|
+        (path + 'puppet-lint/plugins').directory?
+      }.each do |gem_path|
+        Dir["#{(gem_path + 'puppet-lint/plugins').to_s}/*.rb"].each do |file|
+          load file
+        end
+      end
+    end
+  private
+    # Internal: Check if RubyGems is loaded and available.
+    #
+    # Returns true if RubyGems is available, false if not.
+    def self.has_rubygems?
+      defined? ::Gem
+    end
+
+    # Internal: Retrieve a list of available gem paths from RubyGems.
+    #
+    # Returns an Array of Pathname objects.
+    def self.gem_directories
+      if has_rubygems?
+        if Gem::Specification.respond_to? :latest_specs
+          Gem::Specification.latest_specs.map do |spec|
+            Pathname.new(spec.full_gem_path) + 'lib'
+          end
+        else
+          Gem.searcher.init_gemspecs.map do |spec|
+            Pathname.new(spec.full_gem_path) + 'lib'
+          end
+        end
+      else
+        []
+      end
+    end
   end
 end
 
@@ -11,3 +51,5 @@ require 'puppet-lint/plugins/check_strings'
 require 'puppet-lint/plugins/check_variables'
 require 'puppet-lint/plugins/check_whitespace'
 require 'puppet-lint/plugins/check_resources'
+
+PuppetLint::Plugins.load_from_gems

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

@@ -7,7 +7,14 @@ class PuppetLint::Plugins::CheckComments < PuppetLint::CheckPlugin
     tokens.select { |token|
       token.type == :SLASH_COMMENT
     }.each do |token|
-      notify :warning, {
+      if PuppetLint.configuration.fix
+        token.type = :COMMENT
+        notify_type = :fixed
+      else
+        notify_type = :warning
+      end
+
+      notify notify_type, {
         :message    => '// comment found',
         :linenumber => token.line,
         :column     => token.column,

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

@@ -6,7 +6,14 @@ class PuppetLint::Plugins::CheckResources < PuppetLint::CheckPlugin
   check 'unquoted_resource_title' do
     title_tokens.each do |token|
       if token.type == :NAME
-        notify :warning, {
+        if PuppetLint.configuration.fix
+          token.type = :SSTRING
+          notify_type = :fixed
+        else
+          notify_type = :warning
+        end
+
+        notify notify_type, {
           :message    => 'unquoted resource title',
           :linenumber => token.line,
           :column     => token.column,
@@ -102,7 +109,14 @@ class PuppetLint::Plugins::CheckResources < PuppetLint::CheckPlugin
         }.each do |resource_token|
           value_token = resource_token.next_code_token.next_code_token
           if {:NAME => true, :NUMBER => true}.include? value_token.type
-            notify :warning, {
+            if PuppetLint.configuration.fix
+              value_token.type = :SSTRING
+              notify_type = :fixed
+            else
+              notify_type = :warning
+            end
+
+            notify notify_type, {
               :message    => 'unquoted file mode',
               :linenumber => value_token.line,
               :column     => value_token.column,
@@ -142,7 +156,15 @@ class PuppetLint::Plugins::CheckResources < PuppetLint::CheckPlugin
           break if value_token.value =~ sym_mode
           break if value_token.type == :UNDEF
 
-          notify :warning, {
+          notify_type = :warning
+
+          if PuppetLint.configuration.fix && value_token.value =~ /\A[0-7]{3}\Z/
+            value_token.value = "0#{value_token.value.to_s}"
+            value_token.type = :SSTRING
+            notify_type = :fixed
+          end
+
+          notify notify_type, {
             :message    => msg,
             :linenumber => value_token.line,
             :column     => value_token.column,

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

@@ -12,7 +12,14 @@ class PuppetLint::Plugins::CheckStrings < PuppetLint::CheckPlugin
     }.select { |r|
       r.value[/(\t|\\t|\n|\\n)/].nil?
     }.each do |token|
-      notify :warning, {
+      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,
@@ -32,10 +39,36 @@ class PuppetLint::Plugins::CheckStrings < PuppetLint::CheckPlugin
         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 == ''
-              notify :warning, {
+              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
+
+                tokens.delete_at(token_idx + 2)
+                tokens.delete_at(token_idx)
+
+                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]
+              end
+
+              notify notify_type, {
                 :message    => 'string containing only a variable',
-                :linenumber => tokens[token_idx + 1].line,
-                :column     => tokens[token_idx + 1].column,
+                :linenumber => notify_token.line,
+                :column     => notify_token.column,
               }
             end
           end
@@ -53,7 +86,14 @@ class PuppetLint::Plugins::CheckStrings < PuppetLint::CheckPlugin
     tokens.select { |r|
       r.type == :UNENC_VARIABLE
     }.each do |token|
-      notify :warning, {
+      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,
@@ -86,7 +126,14 @@ class PuppetLint::Plugins::CheckStrings < PuppetLint::CheckPlugin
     tokens.select { |r|
       {:STRING => true, :SSTRING => true}.include?(r.type) && %w{true false}.include?(r.value)
     }.each do |token|
-      notify :warning, {
+      if PuppetLint.configuration.fix
+        token.type = token.value.upcase.to_sym
+        notify_type = :fixed
+      else
+        notify_type = :warning
+      end
+
+      notify notify_type, {
         :message    => 'quoted boolean value found',
         :linenumber => token.line,
         :column     => token.column,

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

@@ -4,42 +4,65 @@ class PuppetLint::Plugins::CheckWhitespace < PuppetLint::CheckPlugin
   #
   # Returns nothing.
   check 'hard_tabs' do
-    manifest_lines.each_with_index do |line, idx|
-      if line.include? "\t"
-        notify :error, {
-          :message    => 'tab character found',
-          :linenumber => idx + 1,
-          :column     => line.index("\t") + 1,
-        }
+    tokens.select { |r|
+      [:INDENT, :WHITESPACE].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,
+      }
     end
   end
 
-  # Check the raw manifest string for lines ending with whitespace and record
-  # an error for each instance found.
+  # Check the manifest tokens for lines ending with whitespace and record an
+  # error for each instance found.
   #
   # Returns nothing.
   check 'trailing_whitespace' do
-    manifest_lines.each_with_index do |line, idx|
-      if line.end_with? ' '
-        notify :error, {
-          :message    => 'trailing whitespace found',
-          :linenumber => idx + 1,
-          :column     => line.rindex(' ') + 1,
-        }
+    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,
+      }
     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 puppet:// URLs which would hurt readability if
-  # split.
+  # rule is lines containing URLs which would hurt readability if split.
   #
   # Returns nothing.
   check '80chars' do
     manifest_lines.each_with_index do |line, idx|
-      unless line =~ /puppet:\/\//
+      unless line =~ /:\/\//
         if line.scan(/./mu).size > 80
           notify :warning, {
             :message    => 'line has more than 80 characters',
@@ -75,7 +98,8 @@ class PuppetLint::Plugins::CheckWhitespace < PuppetLint::CheckPlugin
   # Returns nothing.
   check 'arrow_alignment' do
     resource_indexes.each do |res_idx|
-      indent_depth = [nil]
+      indent_depth = [0]
+      indent_depth_idx = 0
       resource_tokens = tokens[res_idx[:start]..res_idx[:end]]
       resource_tokens.reject! do |token|
         {:COMMENT => true, :SLASH_COMMENT => true, :MLCOMMENT => true}.include? token.type
@@ -88,21 +112,40 @@ class PuppetLint::Plugins::CheckWhitespace < PuppetLint::CheckPlugin
         if token.type == :FARROW
           indent_length = token.column
 
-          if indent_depth.last.nil?
-            indent_depth[-1] = indent_length
+          if indent_depth[indent_depth_idx] < indent_length
+            indent_depth[indent_depth_idx] = indent_length
           end
 
-          unless indent_depth.last == indent_length
-            notify :warning, {
+        elsif token.type == :LBRACE
+          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
+            end
+            notify notify_type, {
               :message    => 'indentation of => is not properly aligned',
               :linenumber => token.line,
               :column     => token.column,
             }
           end
         elsif token.type == :LBRACE
-          indent_depth.push(nil)
+          indent_depth_idx += 1
         elsif token.type == :RBRACE
-          indent_depth.pop
+          indent_depth_idx -= 1
         end
       end
     end

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '0.3.2'
+  VERSION = '0.4.0.pre1'
 end

data/puppet-lint.gemspec

@@ -15,7 +15,6 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rdoc'
   s.add_development_dependency 'rcov'
 
   s.authors = ['Tim Sharpe']

data/spec/puppet-lint/configuration_spec.rb

@@ -49,6 +49,7 @@ describe PuppetLint::Configuration do
       'error_level' => :all,
       'log_format' => '',
       'with_context' => false,
+      'fix' => false,
     }
   end
 end

data/spec/puppet-lint/lexer_spec.rb

@@ -654,9 +654,9 @@ describe PuppetLint::Lexer do
     end
 
     it 'should match comments on multiple lines' do
-      token = @lexer.tokenise("/*\n * foo bar\n*/").first
+      token = @lexer.tokenise("/* foo\n * bar\n*/").first
       token.type.should == :MLCOMMENT
-      token.value.should == 'foo bar'
+      token.value.should == "foo\nbar"
     end
   end
 

data/spec/puppet-lint/plugins/check_comments/slash_comments_spec.rb

@@ -13,4 +13,26 @@ describe 'slash_comments' do
       })
     end
   end
+
+  describe 'slash comments w/fix' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    let(:code) { '// foo' }
+
+    its(:problems) do
+      should only_have_problem({
+        :kind       => :fixed,
+        :message    => '// comment found',
+        :linenumber => 1,
+        :column     => 1,
+      })
+    end
+    its(:manifest) { should == '# foo' }
+  end
 end

data/spec/puppet-lint/plugins/check_resources/file_mode_spec.rb

@@ -4,9 +4,35 @@ describe 'file_mode' do
   describe '3 digit file mode' do
     let(:code) { "file { 'foo': mode => '777' }" }
 
-    its(:problems) {
-      should only_have_problem :kind => :warning, :message => "mode should be represented as a 4 digit octal value or symbolic mode", :linenumber => 1
-    }
+    its(:problems) do
+      should only_have_problem({
+        :kind       => :warning,
+        :message    => "mode should be represented as a 4 digit octal value or symbolic mode",
+        :linenumber => 1,
+        :column     => 23,
+      })
+    end
+  end
+
+  describe '3 digit file mode w/fix' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    let(:code) { "file { 'foo': mode => '777' }" }
+
+    its(:manifest) { should == "file { 'foo': mode => '0777' }" }
+    its(:problems) do
+      should only_have_problem({
+        :kind       => :fixed,
+        :message    => 'mode should be represented as a 4 digit octal value or symbolic mode',
+        :linenumber => 1,
+      })
+    end
   end
 
   describe '4 digit file mode' do
@@ -15,29 +41,116 @@ describe 'file_mode' do
     its(:problems) { should be_empty }
   end
 
+  describe '4 digit file mode w/fix' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    let(:code) { "file { 'foo': mode => '0777' }" }
+
+    its(:problems) { should be_empty }
+    its(:manifest) { should == "file { 'foo': mode => '0777' }" }
+  end
+
   describe 'file mode as a variable' do
     let(:code) { "file { 'foo': mode => $file_mode }" }
 
     its(:problems) { should be_empty }
   end
 
+  describe 'file mode as a variable w/fix' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    let(:code) { "file { 'foo': mode => $file_mode }" }
+
+    its(:problems) { should be_empty }
+    its(:manifest) { should == "file { 'foo': mode => $file_mode }" }
+  end
+
   describe 'symbolic file mode' do
     let(:code) { "file { 'foo': mode => 'u=rw,og=r' }" }
 
     its(:problems) { should be_empty }
   end
 
+  describe 'symbolic file mode w/fix' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    let(:code) { "file { 'foo': mode => 'u=rw,og=r' }" }
+
+    its(:problems) { should be_empty }
+    its(:manifest) { should == "file { 'foo': mode => 'u=rw,og=r' }" }
+  end
+
   describe 'file mode undef unquoted' do
     let(:code) { "file { 'foo': mode => undef }" }
 
     its(:problems) { should be_empty }
   end
 
+  describe 'file mode undef unquoted w/fix' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    let(:code) { "file { 'foo': mode => undef }" }
+
+    its(:problems) { should be_empty }
+    its(:manifest) { should == "file { 'foo': mode => undef }" }
+  end
+
+  describe 'file mode undef quoted' do
+    let(:code) { "file { 'foo': mode => 'undef' }" }
+
+    its(:problems) do
+      should only_have_problem({
+        :kind       => :warning,
+        :message    => "mode should be represented as a 4 digit octal value or symbolic mode",
+        :linenumber => 1,
+        :column     => 23,
+      })
+    end
+  end
+
   describe 'file mode undef quoted' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
     let(:code) { "file { 'foo': mode => 'undef' }" }
 
-    its(:problems) {
-      should only_have_problem :kind => :warning, :message => "mode should be represented as a 4 digit octal value or symbolic mode", :linenumber => 1
-    }
+    its(:problems) do
+      should only_have_problem({
+        :kind       => :warning,
+        :message    => "mode should be represented as a 4 digit octal value or symbolic mode",
+        :linenumber => 1,
+        :column     => 23,
+      })
+    end
+    its(:manifest) { should == "file { 'foo': mode => 'undef' }" }
   end
 end