puppet-lint 1.0.1 → 1.1.0

data/README.md

@@ -27,6 +27,40 @@ If you want to test your entire Puppet manifest directory, you can add
 
     rake lint
 
+If you want to modify the default behaviour of the rake task, you can modify
+the PuppetLint configuration by defining the task yourself.
+
+    PuppetLint::RakeTask.new :lint do |config|
+      # Pattern of files to check, defaults to `**/*.pp`
+      config.pattern = 'modules'
+
+      # Pattern of files to ignore
+      config.ignore_paths = ['modules/apt', 'modules/stdlib']
+
+      # List of checks to disable
+      config.disable_checks = ['documentation', '80chars']
+
+      # Should puppet-lint prefix it's output with the file being checked,
+      # defaults to true
+      config.with_filename = false
+
+      # Should the task fail if there were any warnings, defaults to false
+      config.fail_on_warnings = true
+
+      # Format string for puppet-lint's output (see the puppet-lint help output
+      # for details
+      config.log_format = '%{filename} - %{message}'
+
+      # Print out the context for the problem, defaults to false
+      config.with_context = true
+
+      # Enable automatic fixing of problems, defaults to false
+      config.fix = true
+
+      # Show ignored problems in the output, defaults to false
+      config.show_ignored = true
+    end
+
 ## Implemented tests
 
 At the moment, the following tests have been implemented:

data/lib/puppet-lint/data.rb

@@ -255,6 +255,9 @@ class PuppetLint::Data
             rparen_idx = i
             break
           end
+        elsif token.type == :LBRACE && depth == 0
+          # no parameters
+          break
         end
       end
 
@@ -289,6 +292,7 @@ class PuppetLint::Data
     # Returns nothing.
     def parse_control_comments
       @ignore_overrides.each_key { |check| @ignore_overrides[check].clear }
+      control_re = /\A(lint:\S+)(\s+lint:\S+)*(.*)/
 
       comment_token_types = Set[:COMMENT, :MLCOMMENT, :SLASH_COMMENT]
 
@@ -301,28 +305,37 @@ class PuppetLint::Data
 
       stack = []
       control_comment_tokens.each do |token|
-        control, reason = token.value.strip.split(' ', 2)
-        split_control = control.split(':')
-        command = split_control[1]
+        comment_data = control_re.match(token.value.strip).to_a[1..-1].compact.map(&:strip)
+        if comment_data.last =~ /\Alint:(ignore|endignore)/
+          comment_data << ''
+        end
+        reason = comment_data.pop
+        stack_add = []
+        comment_data.each do |control|
+          split_control = control.split(':')
+          command = split_control[1]
 
-        if command == 'ignore'
-          check = split_control[2].to_sym
+          if command == 'ignore'
+            check = split_control[2].to_sym
 
-          if token.prev_token && !Set[:NEWLINE, :INDENT].include?(token.prev_token.type)
-            # control comment at the end of the line, override applies to
-            # a single line only
-            (ignore_overrides[check] ||= {})[token.line] = reason
+            if token.prev_token && !Set[:NEWLINE, :INDENT].include?(token.prev_token.type)
+              # control comment at the end of the line, override applies to
+              # a single line only
+              (ignore_overrides[check] ||= {})[token.line] = reason
+            else
+              stack_add << [token.line, reason, check]
+            end
           else
-            stack << [token.line, reason, check]
-          end
-        else
-          start = stack.pop
-          unless start.nil?
-            (start[0]..token.line).each do |i|
-              (ignore_overrides[start[2]] ||= {})[i] = start[1]
+            stack.pop.each do |start|
+              unless start.nil?
+                (start[0]..token.line).each do |i|
+                  (ignore_overrides[start[2]] ||= {})[i] = start[1]
+                end
+              end
             end
           end
         end
+        stack << stack_add unless stack_add.empty?
       end
     end
   end

data/lib/puppet-lint/lexer.rb

@@ -15,24 +15,22 @@ class PuppetLint
 
     # Internal: Initialise a new PuppetLint::LexerError object.
     #
-    # code   - The String manifest code being tokenised.
-    # offset - The Integer position in the code string that the tokeniser was
-    #          at when it encountered the error.
-    def initialize(code, offset)
-      chunk = code[0..offset]
-      @line_no = chunk.scan(/(\r\n|\r|\n)/).size + 1
-      if @line_no == 1
-        @column = chunk.length
-      else
-        @column = chunk.length - chunk.rindex(/(\r\n|\r|\n)/) - 1
-      end
-      @column = 1 if @column == 0
+    # line_no - The Integer line number of the location of the error.
+    # column  - The Integer column number of the location of the error.
+    def initialize(line_no, column)
+      @line_no = line_no
+      @column = column
     end
   end
 
   # Internal: The puppet-lint lexer. Converts your manifest into its tokenised
   # form.
   class Lexer
+    def initialize
+      @line_no = 1
+      @column = 1
+    end
+
     # Internal: A Hash whose keys are Strings representing reserved keywords in
     # the Puppet DSL.
     KEYWORDS = {
@@ -153,16 +151,17 @@ class PuppetLint
 
         KNOWN_TOKENS.each do |type, regex|
           if value = chunk[regex, 1]
+            length = value.size
             if type == :NAME
               if KEYWORDS.include? value
-                tokens << new_token(value.upcase.to_sym, value, :chunk => code[0..i])
+                tokens << new_token(value.upcase.to_sym, value, length)
               else
-                tokens << new_token(type, value, :chunk => code[0..i])
+                tokens << new_token(type, value, length)
               end
             else
-              tokens << new_token(type, value, :chunk => code[0..i])
+              tokens << new_token(type, value, length)
             end
-            i += value.size
+            i += length
             found = true
             break
           end
@@ -170,68 +169,67 @@ class PuppetLint
 
         unless found
           if var_name = chunk[/\A\$((::)?([\w-]+::)*[\w-]+(\[.+?\])*)/, 1]
-            tokens << new_token(:VARIABLE, var_name, :chunk => code[0..i])
-            i += var_name.size + 1
+            length = var_name.size + 1
+            tokens << new_token(:VARIABLE, var_name, length)
 
           elsif chunk.match(/\A'(.*?)'/m)
             str_content = StringScanner.new(code[i+1..-1]).scan_until(/(\A|[^\\])(\\\\)*'/m)
-            tokens << new_token(:SSTRING, str_content[0..-2], :chunk => code[0..i])
-            i += str_content.size + 1
+            length = str_content.size + 1
+            tokens << new_token(:SSTRING, str_content[0..-2], length)
 
           elsif chunk.match(/\A"/)
             str_contents = StringScanner.new(code[i+1..-1]).scan_until(/(\A|[^\\])(\\\\)*"/m)
             _ = code[0..i].split("\n")
             interpolate_string(str_contents, _.count, _.last.length)
-            i += str_contents.size + 1
+            length = str_contents.size + 1
 
           elsif comment = chunk[/\A(#.*)/, 1]
-            comment_size = comment.size
+            length = comment.size
             comment.sub!(/#/, '')
-            tokens << new_token(:COMMENT, comment, :chunk => code[0..i])
-            i += comment_size
+            tokens << new_token(:COMMENT, comment, length)
 
           elsif slash_comment = chunk[/\A(\/\/.*)/, 1]
-            slash_comment_size = slash_comment.size
+            length = slash_comment.size
             slash_comment.sub!(/\/\//, '')
-            tokens << new_token(:SLASH_COMMENT, slash_comment, :chunk => code[0..i])
-            i += slash_comment_size
+            tokens << new_token(:SLASH_COMMENT, slash_comment, length)
 
           elsif mlcomment = chunk[/\A(\/\*.*?\*\/)/m, 1]
-            mlcomment_size = mlcomment.size
+            length = mlcomment.size
             mlcomment.sub!(/\A\/\* ?/, '')
             mlcomment.sub!(/ ?\*\/\Z/, '')
             mlcomment.gsub!(/ *\* ?/, '')
             mlcomment.strip!
-            tokens << new_token(:MLCOMMENT, mlcomment, :chunk => code[0..i])
-            i += mlcomment_size
+            tokens << new_token(:MLCOMMENT, mlcomment, length)
 
           elsif chunk.match(/\A\/.*?\//) && possible_regex?
             str_content = StringScanner.new(code[i+1..-1]).scan_until(/(\A|[^\\])(\\\\)*\//m)
-            tokens << new_token(:REGEX, str_content[0..-2], :chunk => code[0..i])
-            i += str_content.size + 1
+            length = str_content.size + 1
+            tokens << new_token(:REGEX, str_content[0..-2], length)
 
           elsif eolindent = chunk[/\A((\r\n|\r|\n)[ \t]+)/m, 1]
             eol = eolindent[/\A([\r\n]+)/m, 1]
             indent = eolindent[/\A[\r\n]+([ \t]+)/m, 1]
-            tokens << new_token(:NEWLINE, eol, :chunk => code[0..i])
-            tokens << new_token(:INDENT, indent, :chunk => code[0..i+eol.size])
-            i += indent.size + eol.size
+            tokens << new_token(:NEWLINE, eol, eol.size)
+            tokens << new_token(:INDENT, indent, indent.size)
+            length = indent.size + eol.size
 
           elsif whitespace = chunk[/\A([ \t]+)/, 1]
-            tokens << new_token(:WHITESPACE, whitespace, :chunk => code[0..i])
-            i += whitespace.size
+            length = whitespace.size
+            tokens << new_token(:WHITESPACE, whitespace, length)
 
           elsif eol = chunk[/\A(\r\n|\r|\n)/, 1]
-            tokens << new_token(:NEWLINE, eol, :chunk => code[0..i])
-            i += eol.size
+            length = eol.size
+            tokens << new_token(:NEWLINE, eol, length)
 
           elsif chunk.match(/\A\//)
-            tokens << new_token(:DIV, '/', :chunk => code[0..i])
-            i += 1
+            length = 1
+            tokens << new_token(:DIV, '/', length)
 
           else
-            raise PuppetLint::LexerError.new(code, i)
+            raise PuppetLint::LexerError.new(@line_no, @column)
           end
+
+          i += length
         end
       end
 
@@ -259,29 +257,18 @@ class PuppetLint
     # Internal: Create a new PuppetLint::Lexer::Token object, calculate its
     # line number and column and then add it to the Linked List of tokens.
     #
-    # type  - The Symbol token type.
-    # value - The token value.
-    # opts  - A Hash of additional values required to determine line number and
+    # type   - The Symbol token type.
+    # value  - The token value.
+    # length - The Integer length of the token's value.
+    # opts   - A Hash of additional values required to determine line number and
     #         column:
-    #   :chunk  - The String chunk of the manifest that has been tokenised so
-    #             far.
     #   :line   - The Integer line number if calculated externally.
     #   :column - The Integer column number if calculated externally.
     #
     # Returns the instantiated PuppetLint::Lexer::Token object.
-    def new_token(type, value, opts = {})
-      if opts[:chunk]
-        line_no = opts[:chunk].scan(/(\r\n|\r|\n)/).size + 1
-        if line_no == 1
-          column = opts[:chunk].length
-        else
-          column = opts[:chunk].length - opts[:chunk].rindex(/(\r\n|\r|\n)/) - 1
-        end
-        column += 1 if column == 0
-      else
-        column = opts[:column]
-        line_no = opts[:line]
-      end
+    def new_token(type, value, length, opts = {})
+      column = opts[:column] || @column
+      line_no = opts[:line] || @line_no
 
       token = Token.new(type, value, line_no, column)
       unless tokens.last.nil?
@@ -298,6 +285,12 @@ class PuppetLint
         end
       end
 
+      @column += length
+      if type == :NEWLINE
+        @line_no += 1
+        @column = 1
+      end
+
       token
     end
 
@@ -333,30 +326,30 @@ class PuppetLint
       until value.nil?
         if terminator == "\""
           if first
-            tokens << new_token(:STRING, value, :line => line, :column => column)
+            tokens << new_token(:STRING, value, value.size + 2, :line => line, :column => column)
             first = false
           else
             line += value.scan(/(\r\n|\r|\n)/).size
             token_column = column + (ss.pos - value.size)
-            tokens << new_token(:DQPOST, value, :line => line, :column => token_column)
+            tokens << new_token(:DQPOST, value, value.size + 1, :line => line, :column => token_column)
           end
         else
           if first
-            tokens << new_token(:DQPRE, value, :line => line, :column => column)
+            tokens << new_token(:DQPRE, value, value.size + 1, :line => line, :column => column)
             first = false
           else
             line += value.scan(/(\r\n|\r|\n)/).size
             token_column = column + (ss.pos - value.size)
-            tokens << new_token(:DQMID, value, :line => line, :column => token_column)
+            tokens << new_token(:DQMID, value, value.size, :line => line, :column => token_column)
           end
           if ss.scan(/\{/).nil?
             var_name = ss.scan(/(::)?([\w-]+::)*[\w-]+/)
             if var_name.nil?
               token_column = column + ss.pos - 1
-              tokens << new_token(:DQMID, "$", :line => line, :column => token_column)
+              tokens << new_token(:DQMID, "$", 1, :line => line, :column => token_column)
             else
               token_column = column + (ss.pos - var_name.size)
-              tokens << new_token(:UNENC_VARIABLE, var_name, :line => line, :column => token_column)
+              tokens << new_token(:UNENC_VARIABLE, var_name, var_name.size, :line => line, :column => token_column)
             end
           else
             contents = ss.scan_until(/\}/)[0..-2]
@@ -368,7 +361,7 @@ class PuppetLint
             lexer.tokens.each do |token|
               tok_col = column + token.column + (ss.pos - contents.size - 1)
               tok_line = token.line + line - 1
-              tokens << new_token(token.type, token.value, :line => tok_line, :column => tok_col)
+              tokens << new_token(token.type, token.value, token.value.size, :line => tok_line, :column => tok_col)
             end
           end
         end

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

@@ -186,6 +186,17 @@ PuppetLint.new_check(:variable_scope) do
     'serverip',
     'serverversion',
     'caller_module_name',
+    'alias',
+    'audit',
+    'before',
+    'loglevel',
+    'noop',
+    'notify',
+    'require',
+    'schedule',
+    'stage',
+    'subscribe',
+    'tag',
   ]
   POST_VAR_TOKENS = Set[:COMMA, :EQUALS, :RPAREN]
 

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

@@ -2,17 +2,22 @@
 # each instance found.
 PuppetLint.new_check(:unquoted_node_name) do
   def check
-    tokens.select { |r|
-      r.type == :NODE && r.next_code_token.type == :NAME
-    }.each do |token|
-      value_token = token.next_code_token
-      unless value_token.value == 'default'
-        notify :warning, {
-          :message => 'unquoted node name found',
-          :line    => value_token.line,
-          :column  => value_token.column,
-          :token   => value_token,
-        }
+    node_tokens = tokens.select { |token| token.type == :NODE }
+    node_tokens.each do |node|
+      node_token_idx = tokens.index(node)
+      node_lbrace_idx = tokens.index(tokens.find { |token| token.type == :LBRACE })
+
+      tokens[node_token_idx..node_lbrace_idx].select { |token|
+        token.type == :NAME
+      }.each do |token|
+        unless token.value == 'default'
+          notify :warning, {
+            :message => 'unquoted node name found',
+            :line    => token.line,
+            :column  => token.column,
+            :token   => token,
+          }
+        end
       end
     end
   end

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

@@ -111,7 +111,8 @@ PuppetLint.new_check(:arrow_alignment) do
       resource_tokens.each_with_index do |token, idx|
         if token.type == :FARROW
           (level_tokens[indent_depth_idx] ||= []) << token
-          indent_length = token.prev_token.column + 1
+          prev_indent_token = resource_tokens[0..idx].rindex { |t| t.type == :INDENT }
+          indent_length = resource_tokens[prev_indent_token].to_manifest.length + token.prev_code_token.to_manifest.length + 2
 
           if indent_depth[indent_depth_idx] < indent_length
             indent_depth[indent_depth_idx] = indent_length
@@ -124,12 +125,15 @@ PuppetLint.new_check(:arrow_alignment) do
         elsif token.type == :RBRACE
           level_tokens[indent_depth_idx].each do |arrow_tok|
             unless arrow_tok.column == indent_depth[indent_depth_idx]
+              arrows_on_line = level_tokens[indent_depth_idx].select { |t| t.line == arrow_tok.line }
               notify :warning, {
-                :message      => 'indentation of => is not properly aligned',
-                :line         => arrow_tok.line,
-                :column       => arrow_tok.column,
-                :token        => arrow_tok,
-                :indent_depth => indent_depth[indent_depth_idx],
+                :message        => 'indentation of => is not properly aligned',
+                :line           => arrow_tok.line,
+                :column         => arrow_tok.column,
+                :token          => arrow_tok,
+                :indent_depth   => indent_depth[indent_depth_idx],
+                :newline        => !(arrows_on_line.index(arrow_tok) == 0),
+                :newline_indent => arrows_on_line.first.prev_code_token.prev_token.value,
               }
             end
           end
@@ -142,7 +146,24 @@ PuppetLint.new_check(:arrow_alignment) do
   end
 
   def fix(problem)
-    new_indent = ' ' * (problem[:indent_depth] - problem[:token].prev_token.column)
-    problem[:token].prev_token.value = new_indent
+    new_ws_len = (problem[:indent_depth] - (problem[:newline_indent].length + problem[:token].prev_code_token.to_manifest.length + 1))
+    new_ws = ' ' * new_ws_len
+    if problem[:newline]
+      index = tokens.index(problem[:token].prev_code_token.prev_token)
+
+      #insert newline
+      tokens.insert(index, PuppetLint::Lexer::Token.new(:NEWLINE, "\n", 0, 0))
+
+      # indent the parameter to the correct depth
+      problem[:token].prev_code_token.prev_token.type = :INDENT
+      problem[:token].prev_code_token.prev_token.value = problem[:newline_indent].dup
+    end
+
+    if problem[:token].prev_token.type == :WHITESPACE
+      problem[:token].prev_token.value = new_ws
+    else
+      index = tokens.index(problem[:token].prev_token)
+      tokens.insert(index + 1, PuppetLint::Lexer::Token.new(:WHITESPACE, new_ws, 0, 0))
+    end
   end
 end

data/lib/puppet-lint/tasks/puppet-lint.rb

@@ -11,6 +11,22 @@ class PuppetLint
   #   require 'puppet-lint'
   #   PuppetLint::RakeTask.new
   class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    DEFAULT_PATTERN = '**/*.pp'
+
+    attr_accessor :name
+    attr_accessor :pattern
+    attr_accessor :ignore_paths
+    attr_accessor :with_filename
+    attr_accessor :disable_checks
+    attr_accessor :fail_on_warnings
+    attr_accessor :error_level
+    attr_accessor :log_format
+    attr_accessor :with_context
+    attr_accessor :fix
+    attr_accessor :show_ignored
+
     # Public: Initialise a new PuppetLint::RakeTask.
     #
     # args - Not used.
@@ -18,20 +34,38 @@ class PuppetLint
     # Example
     #
     #   PuppetLint::RakeTask.new
-    def initialize(*args)
+    def initialize(*args, &task_block)
+      @name = args.shift || :lint
+      @pattern = DEFAULT_PATTERN
+      @with_filename = true
+      @disable_checks = []
+      @ignore_paths = []
+
+      define(args, &task_block)
+    end
+
+    def define(args, &task_block)
       desc 'Run puppet-lint'
 
-      task :lint do
-        PuppetLint.configuration.with_filename = true
+      task_block.call(*[self, args].slice(0, task_block.arity)) if task_block
+
+      task @name do
         PuppetLint::OptParser.build
 
+        Array(@disable_checks).each do |check|
+          PuppetLint.configuration.send("disable_#{check}")
+        end
+
+        %w{with_filename fail_on_warnings error_level log_format with_context fix show_ignored}.each do |config|
+          value = instance_variable_get("@#{config}")
+          PuppetLint.configuration.send("#{config}=".to_sym, value) unless value.nil?
+        end
+
         RakeFileUtils.send(:verbose, true) do
           linter = PuppetLint.new
-          matched_files = FileList['**/*.pp']
+          matched_files = FileList[@pattern]
 
-          if ignore_paths = PuppetLint.configuration.ignore_paths
-            matched_files = matched_files.exclude(*ignore_paths)
-          end
+          matched_files = matched_files.exclude(*@ignore_paths)
 
           matched_files.to_a.each do |puppet_file|
             linter.file = puppet_file

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/spec/fixtures/test/manifests/ignore_multiple_block.pp

@@ -0,0 +1,6 @@
+# lint:ignore:double_quoted_strings lint:ignore:quoted_booleans
+"true"
+"false"
+# lint:endignore
+
+"true"

data/spec/fixtures/test/manifests/ignore_multiple_line.pp

@@ -0,0 +1,2 @@
+"true" # lint:ignore:double_quoted_strings lint:ignore:quoted_booleans
+"false" # lint:ignore:quoted_booleans lint:ignore:double_quoted_strings reason

data/spec/puppet-lint/bin_spec.rb

@@ -306,4 +306,21 @@ describe PuppetLint::Bin do
       "  for a good reason",
     ].join("\n")) }
   end
+
+  context 'ignoring multiple checks on a line' do
+    let(:args) { [
+      'spec/fixtures/test/manifests/ignore_multiple_line.pp',
+    ] }
+
+    its(:exitstatus) { is_expected.to eq(0) }
+  end
+
+  context 'ignoring multiple checks in a block' do
+    let(:args) { [
+      'spec/fixtures/test/manifests/ignore_multiple_block.pp',
+    ] }
+
+    its(:exitstatus) { is_expected.to eq(0) }
+    its(:stdout) { is_expected.to match(/^.*line 6$/) }
+  end
 end

data/spec/puppet-lint/ignore_overrides_spec.rb

@@ -94,4 +94,16 @@ describe 'quoted_booleans', :type => :lint do
       expect(problems).to contain_ignored(msg).on_line(5).in_column(7).with_reason('another reason')
     end
   end
+
+  context 'disable multiple checks on a line with a reason' do
+    let(:code) { '"true" # lint:ignore:quoted_booleans lint:ignore:double_quoted_string a reason' }
+
+    it 'should detect 1 problems' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should have one ignored problems' do
+      expect(problems).to contain_ignored(msg).on_line(1).in_column(1).with_reason('a reason')
+    end
+  end
 end

data/spec/puppet-lint/lexer_spec.rb

@@ -13,27 +13,31 @@ describe PuppetLint::Lexer do
 
   context '#new_token' do
     it 'should calculate the line number for an empty string' do
-      token = @lexer.new_token(:TEST, 'test', :chunk => '')
+      token = @lexer.new_token(:TEST, 'test', 4)
       expect(token.line).to eq(1)
     end
 
     it 'should calculate the line number for a multi line string' do
-      token = @lexer.new_token(:TEST, 'test', :chunk => "foo\nbar")
+      @lexer.instance_variable_set('@line_no', 2)
+      token = @lexer.new_token(:TEST, 'test', 4)
       expect(token.line).to eq(2)
     end
 
     it 'should calculate the column number for an empty string' do
-      token = @lexer.new_token(:TEST, 'test', :chunk => '')
+      token = @lexer.new_token(:TEST, 'test', 4)
       expect(token.column).to eq(1)
     end
 
     it 'should calculate the column number for a single line string' do
-      token = @lexer.new_token(:TEST, 'test', :chunk => 'this is a test')
+      @lexer.instance_variable_set('@column', 'this is a test'.size)
+      token = @lexer.new_token(:TEST, 'test', 4)
       expect(token.column).to eq(14)
     end
 
     it 'should calculate the column number for a multi line string' do
-      token = @lexer.new_token(:TEST, 'test', :chunk => "foo\nbar\nbaz\ngronk")
+      @lexer.instance_variable_set('@line_no', 4)
+      @lexer.instance_variable_set('@column', "gronk".size)
+      token = @lexer.new_token(:TEST, 'test', 4)
       expect(token.column).to eq(5)
     end
   end

data/spec/puppet-lint/plugins/check_classes/variable_scope_spec.rb

@@ -165,4 +165,18 @@ describe 'variable_scope' do
       expect(problems).to contain_warning(msg).on_line(6).in_column(11)
     end
   end
+
+  %w{alias audit before loglevel noop notify require schedule stage subscribe tag}.each do |metaparam|
+    context "referencing #{metaparam} metaparam value as a variable" do
+      let(:code) { "
+        class foo() {
+          $#{metaparam}
+        }
+      " }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+  end
 end

data/spec/puppet-lint/plugins/check_nodes/unquoted_node_name_spec.rb

@@ -39,6 +39,33 @@ describe 'unquoted_node_name' do
         expect(problems).to have(0).problems
       end
     end
+
+    context 'multiple bare node names' do
+      let(:code) { "node foo, bar, baz { }" }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create 3 warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(6)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(11)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(16)
+      end
+    end
+
+    context 'mixed node name types' do
+      let(:code) { "node foo, 'bar', baz { }" }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create 2 warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(6)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(18)
+      end
+    end
   end
 
   context 'with fix enabled' do
@@ -65,5 +92,42 @@ describe 'unquoted_node_name' do
         expect(manifest).to eq("node 'foo' { }")
       end
     end
+
+    context 'multiple bare node names' do
+      let(:code) { "node foo, bar, baz { }" }
+      let(:fixed) { "node 'foo', 'bar', 'baz' { }" }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix the 3 problems' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(6)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(11)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(16)
+      end
+
+      it 'should quote all three node names' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'mixed node name types' do
+      let(:code) { "node foo, 'bar', baz { }" }
+      let(:fixed) { "node 'foo', 'bar', 'baz' { }" }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should fix the 2 problems' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(6)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(18)
+      end
+
+      it 'should quote the 2 unquoted node names' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

data/spec/puppet-lint/plugins/check_whitespace/arrow_alignment_spec.rb

@@ -250,6 +250,24 @@ describe 'arrow_alignment' do
         expect(problems).to have(0).problems
       end
     end
+
+    context 'multiline resource with multiple params on a line' do
+      let(:code) { "
+        user { 'test':
+          a => 'foo', bb => 'bar',
+          ccc => 'baz',
+        }
+      " }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create 2 warnings' do
+        expect(problems).to contain_warning(msg).on_line(3).in_column(13)
+        expect(problems).to contain_warning(msg).on_line(3).in_column(26)
+      end
+    end
   end
 
   context 'with fix enabled' do
@@ -399,5 +417,94 @@ describe 'arrow_alignment' do
         expect(manifest).to eq(fixed)
       end
     end
+
+    context 'resource with unaligned => and no whitespace between param and =>' do
+      let(:code) { "
+        user { 'test':
+          param1 => 'foo',
+          param2=> 'bar',
+        }
+      " }
+
+      let(:fixed) { "
+        user { 'test':
+          param1 => 'foo',
+          param2 => 'bar',
+        }
+      " }
+
+      it 'should detect 1 problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the problem' do
+        expect(problems).to contain_fixed(msg).on_line(4).in_column(17)
+      end
+
+      it 'should add whitespace between the param and the arrow' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'multiline resource with multiple params on a line' do
+      let(:code) { "
+        user { 'test':
+          a => 'foo', bb => 'bar',
+          ccc => 'baz',
+        }
+      " }
+
+      let(:fixed) { "
+        user { 'test':
+          a   => 'foo',
+          bb  => 'bar',
+          ccc => 'baz',
+        }
+      " }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should fix 2 problems' do
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(13)
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(26)
+      end
+
+      it 'should move the extra param onto its own line and realign' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'multiline resource with multiple params on a line, extra one longer' do
+      let(:code) { "
+        user { 'test':
+          a => 'foo', bbccc => 'bar',
+          ccc => 'baz',
+        }
+      " }
+
+      let(:fixed) { "
+        user { 'test':
+          a     => 'foo',
+          bbccc => 'bar',
+          ccc   => 'baz',
+        }
+      " }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix 2 problems' do
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(13)
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(29)
+        expect(problems).to contain_fixed(msg).on_line(4).in_column(15)
+      end
+
+      it 'should move the extra param onto its own line and realign' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: puppet-lint
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 1
-  - 0
   - 1
-  version: 1.0.1
+  - 0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Tim Sharpe
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-08-20 00:00:00 +10:00
+date: 2014-09-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -123,6 +123,8 @@ files:
 - puppet-lint.gemspec
 - spec/fixtures/test/manifests/fail.pp
 - spec/fixtures/test/manifests/ignore.pp
+- spec/fixtures/test/manifests/ignore_multiple_block.pp
+- spec/fixtures/test/manifests/ignore_multiple_line.pp
 - spec/fixtures/test/manifests/ignore_reason.pp
 - spec/fixtures/test/manifests/init.pp
 - spec/fixtures/test/manifests/malformed.pp
@@ -203,6 +205,8 @@ summary: Ensure your Puppet manifests conform with the Puppetlabs style guide
 test_files: 
 - spec/fixtures/test/manifests/fail.pp
 - spec/fixtures/test/manifests/ignore.pp
+- spec/fixtures/test/manifests/ignore_multiple_block.pp
+- spec/fixtures/test/manifests/ignore_multiple_line.pp
 - spec/fixtures/test/manifests/ignore_reason.pp
 - spec/fixtures/test/manifests/init.pp
 - spec/fixtures/test/manifests/malformed.pp