puppet-lint 2.3.0 → 2.3.1

data/lib/puppet-lint/bin.rb

@@ -23,8 +23,8 @@ class PuppetLint::Bin
 
     begin
       opts.parse!(@args)
-    rescue OptionParser::InvalidOption
-      puts "puppet-lint: #{$!.message}"
+    rescue OptionParser::InvalidOption => e
+      puts "puppet-lint: #{e.message}"
       puts "puppet-lint: try 'puppet-lint --help' for more information"
       return 1
     end
@@ -35,22 +35,20 @@ class PuppetLint::Bin
     end
 
     if @args[0].nil?
-      puts "puppet-lint: no file specified"
+      puts 'puppet-lint: no file specified'
       puts "puppet-lint: try 'puppet-lint --help' for more information"
       return 1
     end
 
     begin
       path = @args[0]
-      if File.directory?(path)
-        path = Dir.glob("#{path}/**/*.pp")
-      else
-        path = @args
-      end
+      path = if File.directory?(path)
+               Dir.glob("#{path}/**/*.pp")
+             else
+               @args
+             end
 
-      if path.length > 1
-        PuppetLint.configuration.with_filename = true
-      end
+      PuppetLint.configuration.with_filename = true if path.length > 1
 
       return_val = 0
 
@@ -60,24 +58,22 @@ class PuppetLint::Bin
         l.file = f
         l.run
         l.print_problems
-        puts ',' if f != path.last and PuppetLint.configuration.json
+        puts ',' if f != path.last && PuppetLint.configuration.json
 
-        if l.errors? or (l.warnings? and PuppetLint.configuration.fail_on_warnings)
+        if l.errors? || (l.warnings? && PuppetLint.configuration.fail_on_warnings)
           return_val = 1
         end
 
-        if PuppetLint.configuration.fix && !l.problems.any? { |e| e[:check] == :syntax }
-          File.open(f, 'w') do |fd|
-            fd.write l.manifest
-          end
+        next unless PuppetLint.configuration.fix && l.problems.none? { |r| r[:check] == :syntax }
+        File.open(f, 'wb') do |fd|
+          fd.write(l.manifest)
         end
       end
       puts ']' if PuppetLint.configuration.json
 
       return return_val
-
     rescue PuppetLint::NoCodeError
-      puts "puppet-lint: no file specified or specified file does not exist"
+      puts 'puppet-lint: no file specified or specified file does not exist'
       puts "puppet-lint: try 'puppet-lint --help' for more information"
       return 1
     end

data/lib/puppet-lint/checkplugin.rb

@@ -21,11 +21,11 @@ class PuppetLint::CheckPlugin
     check
 
     @problems.each do |problem|
-      if problem[:check] != :syntax && 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
+      next if problem[:check] == :syntax
+      next unless PuppetLint::Data.ignore_overrides[problem[:check]].key?(problem[:line])
+
+      problem[:kind] = :ignored
+      problem[:reason] = PuppetLint::Data.ignore_overrides[problem[:check]][problem[:line]]
     end
 
     @problems
@@ -36,14 +36,13 @@ class PuppetLint::CheckPlugin
   # Returns an Array of problem Hashes.
   def fix_problems
     @problems.reject { |problem| problem[:kind] == :ignored || problem[:check] == :syntax }.each do |problem|
-      if self.respond_to?(:fix)
-        begin
-          fix(problem)
-        rescue PuppetLint::NoFix
-          # noop
-        else
-          problem[:kind] = :fixed
-        end
+      next unless respond_to?(:fix)
+
+      begin
+        fix(problem)
+        problem[:kind] = :fixed
+      rescue PuppetLint::NoFix # rubocop:disable Lint/HandleExceptions
+        # noop
       end
     end
 
@@ -59,6 +58,14 @@ class PuppetLint::CheckPlugin
     PuppetLint::Data.tokens
   end
 
+  def add_token(index, token)
+    PuppetLint::Data.insert(index, token)
+  end
+
+  def remove_token(token)
+    PuppetLint::Data.delete(token)
+  end
+
   # Public: Provides the resource titles to the check plugins.
   #
   # Returns an Array of PuppetLint::Lexer::Token objects.
@@ -159,14 +166,14 @@ class PuppetLint::CheckPlugin
   # Returns nothing.
   def notify(kind, problem)
     problem[:kind] = kind
-    problem.merge!(default_info) { |key, v1, v2| v1 }
+    problem.merge!(default_info) { |_key, v1, _v2| v1 }
 
-    unless [:warning, :error, :fixed].include? kind
-      raise ArgumentError, "unknown value passed for kind"
+    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
+      unless problem.key?(attr)
         raise ArgumentError, "problem hash must contain #{attr.inspect}"
       end
     end

data/lib/puppet-lint/checks.rb

@@ -25,10 +25,16 @@ class PuppetLint::Checks
       PuppetLint::Data.tokens = lexer.tokenise(content)
       PuppetLint::Data.parse_control_comments
     rescue PuppetLint::LexerError => e
+      message = if e.reason.nil?
+                  'Syntax error'
+                else
+                  "Syntax error (#{e.reason})"
+                end
+
       problems << {
         :kind     => :error,
         :check    => :syntax,
-        :message  => 'Syntax error (try running `puppet parser validate <file>`)',
+        :message  => message,
         :line     => e.line_no,
         :column   => e.column,
         :fullpath => PuppetLint::Data.fullpath,
@@ -41,20 +47,16 @@ class PuppetLint::Checks
 
   # Internal: Run the lint checks over the manifest code.
   #
-  # 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.
+  # fileinfo - The path to the file as passed to puppet-lint as a String.
   # data     - The String manifest code to be checked.
   #
   # Returns an Array of problem Hashes.
   def run(fileinfo, data)
     load_data(fileinfo, data)
 
-    checks_run = []
     enabled_checks.each do |check|
       klass = PuppetLint.configuration.check_object[check].new
+      # FIXME: shadowing #problems
       problems = klass.run
 
       if PuppetLint.configuration.fix
@@ -66,25 +68,34 @@ class PuppetLint::Checks
 
     @problems
   rescue => e
-    puts <<-END
-Whoops! It looks like puppet-lint has encountered an error that it doesn't
-know how to handle. Please open an issue at https://github.com/rodjek/puppet-lint
-and paste the following output into the issue description.
----
-puppet-lint version: #{PuppetLint::VERSION}
-ruby version: #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}
-platform: #{RUBY_PLATFORM}
-file path: #{fileinfo}
-file contents:
-```
-#{File.read(fileinfo) if File.readable?(fileinfo)}
-```
-error:
-```
-#{e.class}: #{e.message}
-#{e.backtrace.join("\n")}
-```
-END
+    puts <<-END.gsub(%r{^ {6}}, '')
+      Whoops! It looks like puppet-lint has encountered an error that it doesn't
+      know how to handle. Please open an issue at https://github.com/rodjek/puppet-lint
+      and paste the following output into the issue description.
+      ---
+      puppet-lint version: #{PuppetLint::VERSION}
+      ruby version: #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}
+      platform: #{RUBY_PLATFORM}
+      file path: #{fileinfo}
+    END
+
+    if File.readable?(fileinfo)
+      puts [
+        'file contents:',
+        '```',
+        File.read(fileinfo),
+        '```',
+      ].join("\n")
+    end
+
+    puts [
+      'error:',
+      '```',
+      "#{e.class}: #{e.message}",
+      e.backtrace.join("\n"),
+      '```',
+    ].join("\n")
+
     exit 1
   end
 
@@ -92,17 +103,17 @@ END
   #
   # Returns an Array of String check names.
   def enabled_checks
-    @enabled_checks ||= Proc.new do
-      PuppetLint.configuration.checks.select { |check|
+    @enabled_checks ||= begin
+      PuppetLint.configuration.checks.select do |check|
         PuppetLint.configuration.send("#{check}_enabled?")
-      }
-    end.call
+      end
+    end
   end
 
   # Internal: Render the fixed manifest.
   #
   # Returns the manifest as a String.
   def manifest
-    PuppetLint::Data.tokens.map { |t| t.to_manifest }.join('')
+    PuppetLint::Data.tokens.map(&:to_manifest).join('')
   end
 end

data/lib/puppet-lint/configuration.rb

@@ -49,14 +49,16 @@ class PuppetLint
     # Signature
     #
     #   <option>=(value)
-    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
+    def method_missing(method, *args, &_block)
+      super unless method.to_s =~ %r{^(?<option>\w+)=?$}
+
+      option = Regexp.last_match(:option)
+      add_option(option.to_s) if settings[option].nil?
+      settings[option] = args[0] if args.length > 1
+    end
+
+    def respond_to_missing?(method, *)
+      method.to_s =~ %r{^\w+=?$} || super
     end
 
     # Internal: Add options to the PuppetLint::Configuration object from inside
@@ -149,6 +151,7 @@ class PuppetLint
       self.fix = false
       self.json = false
       self.show_ignored = false
+      self.ignore_paths = ['vendor/**/*.pp']
     end
   end
 end

data/lib/puppet-lint/data.rb

@@ -32,15 +32,28 @@ class PuppetLint::Data
       @defaults_indexes = nil
     end
 
+    def ruby1?
+      @ruby1 = RbConfig::CONFIG['MAJOR'] == '1' if @ruby1.nil?
+      @ruby1
+    end
+
     # Public: Get the tokenised manifest.
     #
     # Returns an Array of PuppetLint::Lexer::Token objects.
     def tokens
-      calling_method = begin
-        caller[0][/`.*'/][1..-2]
-      rescue NoMethodError
-        caller[1][/`.*'/][1..-2]
-      end
+      calling_method = if ruby1?
+                         begin
+                           caller[0][%r{`.*'}][1..-2] # rubocop:disable Performance/Caller
+                         rescue NoMethodError
+                           caller[1][%r{`.*'}][1..-2] # rubocop:disable Performance/Caller
+                         end
+                       else
+                         begin
+                           caller(0..0).first[%r{`.*'}][1..-2]
+                         rescue NoMethodError
+                           caller(1..1).first[%r{`.*'}][1..-2]
+                         end
+                       end
 
       if calling_method == 'check'
         @tokens.dup
@@ -49,6 +62,55 @@ class PuppetLint::Data
       end
     end
 
+    # Public: Add new token.
+    def insert(index, token)
+      current_token = tokens[index - 1]
+      token.next_token = current_token.next_token
+      token.prev_token = current_token
+
+      current_token.next_token.prev_token = token unless current_token.next_token.nil?
+
+      unless formatting_tokens.include?(token.type)
+        current_token.next_token.prev_code_token = token unless current_token.next_token.nil?
+        next_nf_idx = tokens[index..-1].index { |r| !formatting_tokens.include?(r.type) }
+        unless next_nf_idx.nil?
+          next_nf_token = tokens[index + next_nf_idx]
+          token.next_code_token = next_nf_token
+          next_nf_token.prev_code_token = token
+        end
+      end
+
+      if formatting_tokens.include?(current_token.type)
+        prev_nf_idx = tokens[0..index - 1].rindex { |r| !formatting_tokens.include?(r.type) }
+        unless prev_nf_idx.nil?
+          prev_nf_token = tokens[prev_nf_idx]
+          token.prev_code_token = prev_nf_token
+          prev_nf_token.next_code_token = token
+        end
+      else
+        token.prev_code_token = current_token
+      end
+
+      current_token.next_token = token
+      unless formatting_tokens.include?(token.type)
+        current_token.next_code_token = token
+      end
+
+      tokens.insert(index, token)
+    end
+
+    # Public: Removes a token
+    def delete(token)
+      token.next_token.prev_token = token.prev_token unless token.next_token.nil?
+      token.prev_token.next_token = token.next_token unless token.prev_token.nil?
+      unless formatting_tokens.include?(token.type)
+        token.prev_code_token.next_code_token = token.next_code_token unless token.prev_code_token.nil?
+        token.next_code_token.prev_code_token = token.prev_code_token unless token.next_code_token.nil?
+      end
+
+      tokens.delete(token)
+    end
+
     # Internal: Store the path to the manifest file and populate fullpath and
     # filename.
     #
@@ -70,29 +132,27 @@ class PuppetLint::Data
     #
     # Returns an Array of PuppetLint::Lexer::Token objects.
     def title_tokens
-      @title_tokens ||= Proc.new do
+      @title_tokens ||= begin
         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|
+            if tokens[token_idx - 1].type == :RBRACK
+              array_start_idx = tokens.rindex do |r|
                 r.type == :LBRACK
-              }
+              end
               title_array_tokens = tokens[(array_start_idx + 1)..(token_idx - 2)]
-              result += title_array_tokens.select { |token|
-                {:STRING => true, :NAME => true}.include? token.type
-              }
+              result += title_array_tokens.select do |token|
+                { :STRING => true, :NAME => true }.include?(token.type)
+              end
             else
               next_token = tokens[token_idx].next_code_token
-              if next_token.type != :LBRACE
-                result << tokens[token_idx - 1]
-              end
+              result << tokens[token_idx - 1] unless next_token.type == :LBRACE
             end
           end
         end
         result
-      end.call
+      end
     end
 
     # Internal: Calculate the positions of all resource declarations within the
@@ -109,21 +169,21 @@ class PuppetLint::Data
         marker = 0
         result = []
         tokens.select { |t| t.type == :COLON }.each do |colon_token|
-          if colon_token.next_code_token && colon_token.next_code_token.type != :LBRACE
-            start_idx = tokens.index(colon_token)
-            next if start_idx < marker
-            end_token = colon_token.next_token_of([:SEMIC, :RBRACE])
-            end_idx = tokens.index(end_token)
-
-            result << {
-              :start        => start_idx + 1,
-              :end          => end_idx,
-              :tokens       => tokens[start_idx..end_idx],
-              :type         => find_resource_type_token(start_idx),
-              :param_tokens => find_resource_param_tokens(tokens[start_idx..end_idx]),
-            }
-            marker = end_idx
-          end
+          next unless colon_token.next_code_token && colon_token.next_code_token.type != :LBRACE
+
+          start_idx = tokens.index(colon_token)
+          next if start_idx < marker
+          end_token = colon_token.next_token_of([:SEMIC, :RBRACE])
+          end_idx = tokens.index(end_token)
+
+          result << {
+            :start        => start_idx + 1,
+            :end          => end_idx,
+            :tokens       => tokens[start_idx..end_idx],
+            :type         => find_resource_type_token(start_idx),
+            :param_tokens => find_resource_param_tokens(tokens[start_idx..end_idx]),
+          }
+          marker = end_idx
         end
         result
       end
@@ -136,9 +196,9 @@ class PuppetLint::Data
     #
     # Returns a Token object.
     def find_resource_type_token(index)
-      lbrace_idx = tokens[0..index].rindex { |token|
+      lbrace_idx = tokens[0..index].rindex do |token|
         token.type == :LBRACE && token.prev_code_token.type != :QMARK
-      }
+      end
       tokens[lbrace_idx].prev_code_token
     end
 
@@ -150,9 +210,9 @@ class PuppetLint::Data
     #
     # Returns an Array of Token objects.
     def find_resource_param_tokens(resource_tokens)
-      resource_tokens.select { |token|
+      resource_tokens.select do |token|
         token.type == :NAME && token.next_code_token.type == :FARROW
-      }
+      end
     end
 
     # Internal: Calculate the positions of all class definitions within the
@@ -210,38 +270,38 @@ class PuppetLint::Data
     def definition_indexes(type)
       result = []
       tokens.each_with_index do |token, i|
-        if token.type == type
-          brace_depth = 0
-          paren_depth = 0
-          in_params = false
-          inherited_class = nil
-          tokens[i+1..-1].each_with_index do |definition_token, j|
-            case definition_token.type
-            when :INHERITS
-              inherited_class = definition_token.next_code_token
-            when :LPAREN
-              in_params = true if paren_depth == 0
-              paren_depth += 1
-            when :RPAREN
-              in_params = false if paren_depth == 1
-              paren_depth -= 1
-            when :LBRACE
-              brace_depth += 1
-            when :RBRACE
-              brace_depth -= 1
-              if brace_depth == 0 && !in_params
-                if token.next_code_token.type != :LBRACE
-                  result << {
-                    :start           => i,
-                    :end             => i + j + 1,
-                    :tokens          => tokens[i..(i + j + 1)],
-                    :param_tokens    => param_tokens(tokens[i..(i + j + 1)]),
-                    :type            => type,
-                    :name_token      => token.next_code_token,
-                    :inherited_token => inherited_class,
-                  }
-                  break
-                end
+        next unless token.type == type
+
+        brace_depth = 0
+        paren_depth = 0
+        in_params = false
+        inherited_class = nil
+        tokens[i + 1..-1].each_with_index do |definition_token, j|
+          case definition_token.type
+          when :INHERITS
+            inherited_class = definition_token.next_code_token
+          when :LPAREN
+            in_params = true if paren_depth.zero?
+            paren_depth += 1
+          when :RPAREN
+            in_params = false if paren_depth == 1
+            paren_depth -= 1
+          when :LBRACE
+            brace_depth += 1
+          when :RBRACE
+            brace_depth -= 1
+            if brace_depth.zero? && !in_params
+              if token.next_code_token.type != :LBRACE
+                result << {
+                  :start           => i,
+                  :end             => i + j + 1,
+                  :tokens          => tokens[i..(i + j + 1)],
+                  :param_tokens    => param_tokens(tokens[i..(i + j + 1)]),
+                  :type            => type,
+                  :name_token      => token.next_code_token,
+                  :inherited_token => inherited_class,
+                }
+                break
               end
             end
           end
@@ -261,41 +321,42 @@ class PuppetLint::Data
     #   :tokens - An Array consisting of all the Token objects that make up the
     #             function call.
     def function_indexes
-      @function_indexes ||= Proc.new do
+      @function_indexes ||= begin
         functions = []
         tokens.each_with_index do |token, token_idx|
-          if token.type == :NAME && \
-            (token_idx == 0 || (token_idx == 1 && tokens[0].type == :WHITESPACE) || token.prev_token.type == :NEWLINE || token.prev_token.type == :INDENT || \
-              # function in a function
-              (token.prev_code_token && token.prev_code_token.type == :LPAREN))
-
-              # Hash key
-              next if token.next_code_token && token.next_code_token.type == :FARROW
-
-              level = 0
-              real_idx = 0
-              in_paren = false
-              tokens[token_idx+1..-1].each_with_index do |cur_token, cur_token_idx|
-                break if level == 0 && in_paren
-                break if level == 0 && cur_token.type == :NEWLINE
-
-                if cur_token.type == :LPAREN
-                  level += 1
-                  in_paren = true
-                end
-                level -= 1 if cur_token.type == :RPAREN
-                real_idx = token_idx + 1 + cur_token_idx
-              end
-
-              functions << {
-                :start  => token_idx,
-                :end    => real_idx,
-                :tokens => tokens[token_idx..real_idx],
-              }         
+          next unless token.type == :NAME
+          next unless token_idx.zero? ||
+                      (token_idx == 1 && tokens[0].type == :WHITESPACE) ||
+                      [:NEWLINE, :INDENT].include?(token.prev_token.type) ||
+                      # function in a function
+                      (token.prev_code_token && token.prev_code_token.type == :LPAREN)
+
+          # Hash key
+          next if token.next_code_token && token.next_code_token.type == :FARROW
+
+          level = 0
+          real_idx = 0
+          in_paren = false
+          tokens[token_idx + 1..-1].each_with_index do |cur_token, cur_token_idx|
+            break if level.zero? && in_paren
+            break if level.zero? && cur_token.type == :NEWLINE
+
+            if cur_token.type == :LPAREN
+              level += 1
+              in_paren = true
+            end
+            level -= 1 if cur_token.type == :RPAREN
+            real_idx = token_idx + 1 + cur_token_idx
           end
+
+          functions << {
+            :start  => token_idx,
+            :end    => real_idx,
+            :tokens => tokens[token_idx..real_idx],
+          }
         end
         functions
-      end.call
+      end
     end
 
     # Internal: Calculate the positions of all array values within
@@ -309,28 +370,29 @@ class PuppetLint::Data
     #   :tokens - An Array consisting of all the Token objects that make up the
     #             array value.
     def array_indexes
-      @array_indexes ||= Proc.new do
+      @array_indexes ||= begin
         arrays = []
         tokens.each_with_index do |token, token_idx|
-          if token.type == :LBRACK
-            real_idx = 0
-            tokens[token_idx+1..-1].each_with_index do |cur_token, cur_token_idx|
-              real_idx = token_idx + 1 + cur_token_idx
-              break if cur_token.type == :RBRACK
-            end
+          next unless token.type == :LBRACK
 
-            # Ignore resource references
-            next if token.prev_code_token && \
-              token.prev_code_token.type == :CLASSREF
-            arrays << {
-              :start  => token_idx,
-              :end    => real_idx,
-              :tokens => tokens[token_idx..real_idx],
-            }
+          real_idx = 0
+          tokens[token_idx + 1..-1].each_with_index do |cur_token, cur_token_idx|
+            real_idx = token_idx + 1 + cur_token_idx
+            break if cur_token.type == :RBRACK
           end
+
+          # Ignore resource references
+          next if token.prev_code_token &&
+                  token.prev_code_token.type == :CLASSREF
+
+          arrays << {
+            :start  => token_idx,
+            :end    => real_idx,
+            :tokens => tokens[token_idx..real_idx],
+          }
         end
         arrays
-      end.call
+      end
     end
 
     # Internal: Calculate the positions of all hash values within
@@ -344,31 +406,31 @@ class PuppetLint::Data
     #   :tokens - An Array consisting of all the Token objects that make up the
     #             hash value.
     def hash_indexes
-      @hash_indexes ||= Proc.new do
+      @hash_indexes ||= begin
         hashes = []
         tokens.each_with_index do |token, token_idx|
+          next unless token.type == :LBRACE
           next unless token.prev_code_token
-          next unless [:EQUALS, :ISEQUAL, :FARROW, :LPAREN].include? token.prev_code_token.type
-          if token.type == :LBRACE
-            level = 0
-            real_idx = 0
-            tokens[token_idx+1..-1].each_with_index do |cur_token, cur_token_idx|
-              real_idx = token_idx + 1 + cur_token_idx
-
-              level += 1 if cur_token.type == :LBRACE
-              level -= 1 if cur_token.type == :RBRACE
-              break if level < 0
-            end
+          next unless [:EQUALS, :ISEQUAL, :FARROW, :LPAREN].include?(token.prev_code_token.type)
+
+          level = 0
+          real_idx = 0
+          tokens[token_idx + 1..-1].each_with_index do |cur_token, cur_token_idx|
+            real_idx = token_idx + 1 + cur_token_idx
 
-            hashes << {
-              :start  => token_idx,
-              :end    => real_idx,
-              :tokens => tokens[token_idx..real_idx],
-            }
+            level += 1 if cur_token.type == :LBRACE
+            level -= 1 if cur_token.type == :RBRACE
+            break if level < 0
           end
+
+          hashes << {
+            :start  => token_idx,
+            :end    => real_idx,
+            :tokens => tokens[token_idx..real_idx],
+          }
         end
         hashes
-      end.call
+      end
     end
 
     # Internal: Calculate the positions of all defaults declarations within
@@ -382,27 +444,27 @@ class PuppetLint::Data
     #   :tokens - An Array consisting of all the Token objects that make up the
     #             defaults declaration.
     def defaults_indexes
-      @defaults_indexes ||= Proc.new do
+      @defaults_indexes ||= begin
         defaults = []
         tokens.each_with_index do |token, token_idx|
-          if token.type == :CLASSREF && token.next_code_token && \
-            token.next_code_token.type == :LBRACE
-            real_idx = 0
+          next unless token.type == :CLASSREF
+          next unless token.next_code_token && token.next_code_token.type == :LBRACE
 
-            tokens[token_idx+1..-1].each_with_index do |cur_token, cur_token_idx|
-              real_idx = token_idx + 1 + cur_token_idx
-              break if cur_token.type == :RBRACE
-            end
+          real_idx = 0
 
-            defaults << {
-              :start  => token_idx,
-              :end    => real_idx,
-              :tokens => tokens[token_idx..real_idx],
-            }
+          tokens[token_idx + 1..-1].each_with_index do |cur_token, cur_token_idx|
+            real_idx = token_idx + 1 + cur_token_idx
+            break if cur_token.type == :RBRACE
           end
+
+          defaults << {
+            :start  => token_idx,
+            :end    => real_idx,
+            :tokens => tokens[token_idx..real_idx],
+          }
         end
         defaults
-      end.call
+      end
     end
 
     # Internal: Finds all the tokens that make up the defined type or class
@@ -424,17 +486,17 @@ class PuppetLint::Data
           lparen_idx = i if depth == 1
         elsif token.type == :RPAREN
           depth -= 1
-          if depth == 0
+          if depth.zero?
             rparen_idx = i
             break
           end
-        elsif token.type == :LBRACE && depth == 0
+        elsif token.type == :LBRACE && depth.zero?
           # no parameters
           break
         end
       end
 
-      if lparen_idx.nil? or rparen_idx.nil?
+      if lparen_idx.nil? || rparen_idx.nil?
         nil
       else
         these_tokens[(lparen_idx + 1)..(rparen_idx - 1)]
@@ -465,25 +527,35 @@ 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]
 
-      comment_tokens = tokens.select { |token|
+      comment_tokens = tokens.select do |token|
         comment_token_types.include?(token.type)
-      }
-      control_comment_tokens = comment_tokens.select { |token|
-        token.value.strip =~ /\Alint:(ignore:[\w\d]+|endignore)/
-      }
+      end
+      control_comment_tokens = comment_tokens.select do |token|
+        token.value.strip =~ %r{\Alint\:(ignore\:[\w\d]+|endignore)}
+      end
 
       stack = []
       control_comment_tokens.each do |token|
-        comment_data = control_re.match(token.value.strip).to_a[1..-1].compact.map(&:strip)
-        if comment_data.last =~ /\Alint:(ignore|endignore)/
-          comment_data << ''
+        comment_data = []
+        reason = []
+
+        comment_words = token.value.strip.split(%r{\s+})
+        comment_words.each_with_index do |word, i|
+          if word =~ %r{\Alint\:(ignore|endignore)}
+            comment_data << word
+          else
+            # Once we reach the first non-controlcomment word, assume the rest
+            # of the words are the reason.
+            reason = comment_words[i..-1]
+            break
+          end
         end
-        reason = comment_data.pop
+
         stack_add = []
+
         comment_data.each do |control|
           split_control = control.split(':')
           command = split_control[1]
@@ -493,9 +565,9 @@ class PuppetLint::Data
             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
+              (ignore_overrides[check] ||= {})[token.line] = reason.join(' ')
             else
-              stack_add << [token.line, reason, check]
+              stack_add << [token.line, reason.join(' '), check]
             end
           else
             top_override = stack.pop
@@ -505,10 +577,10 @@ class PuppetLint::Data
               puts "WARNING: lint:endignore comment with no opening lint:ignore:<check> comment found on line #{token.line}"
             else
               top_override.each do |start|
-                unless start.nil?
-                  (start[0]..token.line).each do |i|
-                    (ignore_overrides[start[2]] ||= {})[i] = start[1]
-                  end
+                next if start.nil?
+
+                (start[0]..token.line).each do |i|
+                  (ignore_overrides[start[2]] ||= {})[i] = start[1]
                 end
               end
             end