puppet-lint 0.4.0.pre1 → 1.0.0

data/lib/puppet-lint/lexer/token.rb

@@ -1,35 +1,37 @@
 class PuppetLint
   class Lexer
+    # Public: Stores a fragment of the manifest and the information about its
+    # location in the manifest.
     class Token
-      # Internal: Returns the Symbol type of the Token.
+      # Public: Returns the Symbol type of the Token.
       attr_accessor :type
 
-      # Internal: Returns the String value of the Token.
+      # Public: Returns the String value of the Token.
       attr_accessor :value
 
-      # Internal: Returns the Integer line number of the manifest text where
+      # Public: Returns the Integer line number of the manifest text where
       # the Token can be found.
       attr_reader :line
 
-      # Internal: Returns the Integer column number of the line of the manifest
+      # Public: Returns the Integer column number of the line of the manifest
       # text where the Token can be found.
       attr_reader :column
 
-      # Internal: Gets/sets the next token in the manifest.
+      # Public: Gets/sets the next token in the manifest.
       attr_accessor :next_token
 
-      # Internal: Gets/sets the previous token in the manifest.
+      # Public: Gets/sets the previous token in the manifest.
       attr_accessor :prev_token
 
-      # Internal: Gets/sets the next code token (skips whitespace, comments,
+      # Public: Gets/sets the next code token (skips whitespace, comments,
       # etc) in the manifest.
       attr_accessor :next_code_token
 
-      # Internal: Gets/sets the previous code tokne (skips whitespace,
+      # Public: Gets/sets the previous code tokne (skips whitespace,
       # comments, etc) in the manifest.
       attr_accessor :prev_code_token
 
-      # Internal: Initialise a new Token object.
+      # Public: Initialise a new Token object.
       #
       # type   - An upper case Symbol describing the type of Token.
       # value  - The String value of the Token.
@@ -50,7 +52,7 @@ class PuppetLint
         @prev_code_token = nil
       end
 
-      # Internal: Produce a human friendly description of the Token when
+      # Public: Produce a human friendly description of the Token when
       # inspected.
       #
       # Returns a String describing the Token.
@@ -58,7 +60,7 @@ class PuppetLint
         "<Token #{@type.inspect} (#{@value}) @#{@line}:#{@column}>"
       end
 
-      # Internal: Produce a Puppet DSL representation of a Token.
+      # Public: Produce a Puppet DSL representation of a Token.
       #
       # Returns a Puppet DSL String.
       def to_manifest
@@ -82,11 +84,7 @@ class PuppetLint
         when :NEWLINE
           "\n"
         when :COMMENT
-          if @value.start_with?('#') || @value.empty?
-            "##{@value}"
-          else
-            "# #{@value}"
-          end
+          "##{@value}"
         when :REGEX
           "/#{@value}/"
         else

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

@@ -1,5 +1,11 @@
 unless String.respond_to?('prepend')
+  # Internal: Monkey patching String.
   class String
+    # Internal: Prepends a String to self.
+    #
+    # lead - The String to prepend self with.
+    #
+    # Returns a String which is lead and self concatenated.
     def prepend(lead)
       self.replace "#{lead}#{self}"
     end

data/lib/puppet-lint/optparser.rb

@@ -0,0 +1,105 @@
+require 'optparse'
+
+# Public: Contains the puppet-lint option parser so that it can be used easily
+# in multiple places.
+class PuppetLint::OptParser
+  HELP_TEXT = <<-EOF
+    puppet-lint
+
+    Basic Command Line Usage:
+      puppet-lint [OPTIONS] PATH
+
+            PATH                         The path to the Puppet manifest.
+
+    Option:
+  EOF
+
+  # Public: Initialise a new puppet-lint OptionParser.
+  #
+  # Returns an OptionParser object.
+  def self.build
+    OptionParser.new do |opts|
+      opts.banner = HELP_TEXT
+
+      opts.on('--version', 'Display the current version.') do
+        PuppetLint.configuration.display_version = true
+      end
+
+      opts.on('-c', '--config FILE', 'Load puppet-lint options from file.') do |file|
+        opts.load(file)
+      end
+
+      opts.on('--with-context', 'Show where in the manifest the problem is.') do
+        PuppetLint.configuration.with_context = true
+      end
+
+      opts.on('--with-filename', 'Display the filename before the warning.') do
+        PuppetLint.configuration.with_filename = true
+      end
+
+      opts.on('--fail-on-warnings', 'Return a non-zero exit status for warnings') do
+        PuppetLint.configuration.fail_on_warnings = true
+      end
+
+      opts.on('--error-level LEVEL', [:all, :warning, :error],
+              'The level of error to return (warning, error or all).') do |el|
+        PuppetLint.configuration.error_level = el
+      end
+
+      opts.on('--show-ignored', 'Show problems that have been ignored by control comments') do
+        PuppetLint.configuration.show_ignored = true
+      end
+
+      opts.on('--relative', 'Compare module layout relative to the module root') do
+        PuppetLint.configuration.relative = true
+      end
+
+      opts.on('-l', '--load FILE', 'Load a file containing custom puppet-lint checks.') do |f|
+        load f
+      end
+
+      opts.on('-f', '--fix', 'Attempt to automatically fix errors') do
+        PuppetLint.configuration.fix = 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 to puppet-lint.',
+              '%{fullpath} - Expanded path to the file.',
+              '%{line}     - Line number.',
+              '%{column}   - Column number.',
+              '%{kind}     - The kind of message (warning, error).',
+              '%{KIND}     - Uppercase version of %{kind}.',
+              '%{check}    - The name of the check.',
+              '%{message}  - The message.'
+      ) do |format|
+        if format.include?('%{linenumber}')
+          $stderr.puts "DEPRECATION: Please use %{line} instead of %{linenumber}"
+        end
+        PuppetLint.configuration.log_format = format
+      end
+
+      opts.separator ''
+      opts.separator '    Checks:'
+
+      opts.on('--only-checks CHECKS', 'A comma separated list of checks that should be run') do |checks|
+        enable_checks = checks.split(',').map(&:to_sym)
+        (PuppetLint.configuration.checks - enable_checks).each do |check|
+          PuppetLint.configuration.send("disable_#{check}")
+        end
+      end
+
+      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('/etc/puppet-lint.rc')
+      opts.load(File.expand_path('~/.puppet-lint.rc')) if ENV['HOME']
+      opts.load('.puppet-lint.rc')
+    end
+  end
+end

data/lib/puppet-lint/plugins.rb

@@ -1,8 +1,13 @@
 require 'pathname'
 
 class PuppetLint
+  # Public: Various methods that implement puppet-lint's plugin system
+  #
+  # Examples
+  #
+  #   PuppetLint::Plugins.load_spec_helper
   class Plugins
-    # Public: Find any gems containing puppet-lint plugins and load them.
+    # Internal: Find any gems containing puppet-lint plugins and load them.
     #
     # Returns nothing.
     def self.load_from_gems
@@ -14,6 +19,14 @@ class PuppetLint
         end
       end
     end
+
+    # Public: Load the puppet-lint spec_helper.rb
+    #
+    # Returns nothings.
+    def self.load_spec_helper
+      gemspec = gemspecs.select { |spec| spec.name == 'puppet-lint' }.first
+      load Pathname.new(gemspec.full_gem_path) + 'spec/spec_helper.rb'
+    end
   private
     # Internal: Check if RubyGems is loaded and available.
     #
@@ -22,19 +35,24 @@ class PuppetLint
       defined? ::Gem
     end
 
+    # Internal: Retrieve a list of avaliable gemspecs.
+    #
+    # Returns an Array of Gem::Specification objects.
+    def self.gemspecs
+      @gemspecs ||= if Gem::Specification.respond_to?(:latest_specs)
+        Gem::Specification.latest_specs
+      else
+        Gem.searcher.init_gemspecs
+      end
+    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
+        gemspecs.reject { |spec| spec.name == 'puppet-lint' }.map do |spec|
+          Pathname.new(spec.full_gem_path) + 'lib'
         end
       else
         []
@@ -51,5 +69,6 @@ require 'puppet-lint/plugins/check_strings'
 require 'puppet-lint/plugins/check_variables'
 require 'puppet-lint/plugins/check_whitespace'
 require 'puppet-lint/plugins/check_resources'
+require 'puppet-lint/plugins/check_nodes'
 
 PuppetLint::Plugins.load_from_gems

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

@@ -1,200 +1,115 @@
-class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
-  # Public: Test the manifest tokens for any right-to-left (<-) chaining
-  # operators and record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'right_to_left_relationship' do
+# Public: Test the manifest tokens for any right-to-left (<-) chaining
+# operators and record a warning for each instance found.
+PuppetLint.new_check(:right_to_left_relationship) do
+  def check
     tokens.select { |r| r.type == :OUT_EDGE }.each do |token|
       notify :warning, {
-        :message    =>  'right-to-left (<-) relationship',
-        :linenumber => token.line,
-        :column     => token.column,
+        :message =>  'right-to-left (<-) relationship',
+        :line    => token.line,
+        :column  => token.column,
       }
     end
   end
+end
 
-  # Public: Test the manifest tokens for any classes or defined types that are
-  # not in an appropriately named file for the autoloader to detect and record
-  # an error of each instance found.
-  #
-  # Returns nothing.
-  check 'autoloader_layout' do
-    unless fullpath == ''
+# Public: Test the manifest tokens for any classes or defined types that are
+# not in an appropriately named file for the autoloader to detect and record
+# an error of each instance found.
+PuppetLint.new_check(:autoloader_layout) do
+  def check
+    unless fullpath.nil? || fullpath == ''
       (class_indexes + defined_type_indexes).each do |class_idx|
-        class_tokens = tokens[class_idx[:start]..class_idx[:end]]
-        title_token = class_tokens[class_tokens.index { |r| r.type == :NAME }]
+        title_token = class_idx[:name_token]
         split_title = title_token.value.split('::')
         mod = split_title.first
         if split_title.length > 1
-          expected_path = "#{mod}/manifests/#{split_title[1..-1].join('/')}.pp"
+          expected_path = "/#{mod}/manifests/#{split_title[1..-1].join('/')}.pp"
         else
-          expected_path = "#{title_token.value}/manifests/init.pp"
+          expected_path = "/#{title_token.value}/manifests/init.pp"
+        end
+
+        if PuppetLint.configuration.relative
+          expected_path = expected_path.gsub(/^\//,'').split('/')[1..-1].join('/')
         end
 
         unless fullpath.end_with? expected_path
           notify :error, {
-            :message    => "#{title_token.value} not in autoload module layout",
-            :linenumber => title_token.line,
-            :column     => title_token.column,
+            :message => "#{title_token.value} not in autoload module layout",
+            :line    => title_token.line,
+            :column  => title_token.column,
           }
         end
       end
     end
   end
+end
 
-  # Public: Check the manifest tokens for any classes or defined types that
-  # have a dash in their name and record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'names_containing_dash' do
+# Public: Check the manifest tokens for any classes or defined types that
+# have a dash in their name and record a warning for each instance found.
+PuppetLint.new_check(:names_containing_dash) do
+  def check
     (class_indexes + defined_type_indexes).each do |class_idx|
-      class_tokens = tokens[class_idx[:start]..class_idx[:end]]
-      title_token = class_tokens[class_tokens.index { |r| r.type == :NAME }]
-
-      if title_token.value.include? '-'
-        if class_tokens.first.type == :CLASS
+      if class_idx[:name_token].value.include? '-'
+        if class_idx[:type] == :CLASS
           obj_type = 'class'
         else
           obj_type = 'defined type'
         end
 
         notify :warning, {
-          :message    => "#{obj_type} name containing a dash",
-          :linenumber => title_token.line,
-          :column     => title_token.column,
+          :message => "#{obj_type} name containing a dash",
+          :line    => class_idx[:name_token].line,
+          :column  => class_idx[:name_token].column,
         }
       end
     end
   end
+end
 
-  check 'class_inherits_from_params_class' do
+# Public: Check the manifest tokens for any classes that inherit a params
+# subclass and record a warning for each instance found.
+PuppetLint.new_check(:class_inherits_from_params_class) do
+  def check
     class_indexes.each do |class_idx|
-      class_tokens = tokens[class_idx[:start]..class_idx[:end]]
-      inherits_idx = class_tokens.index { |r| r.type == :INHERITS }
-      unless inherits_idx.nil?
-        inherited_class_token = class_tokens[inherits_idx].next_code_token
-        if inherited_class_token.value.end_with? '::params'
+      unless class_idx[:inherited_token].nil?
+        if class_idx[:inherited_token].value.end_with? '::params'
           notify :warning, {
-            :message    => 'class inheriting from params class',
-            :linenumber => inherited_class_token.line,
-            :column     => inherited_class_token.column,
+            :message => 'class inheriting from params class',
+            :line    => class_idx[:inherited_token].line,
+            :column  => class_idx[:inherited_token].column,
           }
         end
       end
     end
   end
+end
 
-  check 'class_parameter_defaults' do
-    class_indexes.each do |class_idx|
-      token_idx = class_idx[:start]
-      depth = 0
-      lparen_idx = nil
-      rparen_idx = nil
-      class_name_token = tokens[class_idx[:start]].next_code_token
-
-      if class_name_token.next_code_token.type == :LPAREN
-        tokens[token_idx..-1].each_index do |t|
-          idx = token_idx + t
-          if tokens[idx].type == :LPAREN
-            depth += 1
-            lparen_idx = idx if depth == 1
-          elsif tokens[idx].type == :RPAREN
-            depth -= 1
-            if depth == 0
-              rparen_idx = idx
-              break
-            end
-          end
-        end
-      end
-
-      unless lparen_idx.nil? or rparen_idx.nil?
-        param_tokens = tokens[lparen_idx+1..rparen_idx-1].reject { |r|
-          formatting_tokens.include? r.type
-        }
-
-        paren_stack = []
-        param_tokens.each_index do |param_tokens_idx|
-          this_token = param_tokens[param_tokens_idx]
-          next_token = this_token.next_code_token
-          prev_token = this_token.prev_code_token
-
-          if this_token.type == :LPAREN
-            paren_stack.push(true)
-          elsif this_token.type == :RPAREN
-            paren_stack.pop
-          end
-          next unless paren_stack.empty?
-
-          if this_token.type == :VARIABLE
-            if !next_token.nil? && next_token.type != :EQUALS
-              if !prev_token.nil? && prev_token.type != :EQUALS
-                notify :warning, {
-                  :message    => 'parameterised class parameter without a default value',
-                  :linenumber => this_token.line,
-                  :column     => this_token.column,
-                }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  # Public: Test the manifest tokens for any parameterised classes or defined
-  # types that take parameters and record a warning if there are any optional
-  # parameters listed before required parameters.
-  #
-  # Returns nothing.
-  check 'parameter_order' do
+# Public: Test the manifest tokens for any parameterised classes or defined
+# types that take parameters and record a warning if there are any optional
+# parameters listed before required parameters.
+PuppetLint.new_check(:parameter_order) do
+  def check
     defined_type_indexes.each do |class_idx|
-      token_idx = class_idx[:start]
-      depth = 0
-      lparen_idx = nil
-      rparen_idx = nil
-      tokens[token_idx..-1].each_index do |t|
-        idx = token_idx + t
-        if tokens[idx].type == :LPAREN
-          depth += 1
-          lparen_idx = idx if depth == 1
-        elsif tokens[idx].type == :RPAREN
-          depth -= 1
-          if depth == 0
-            rparen_idx = idx
-            break
-          end
-        end
-      end
-
-      unless lparen_idx.nil? or rparen_idx.nil?
-        param_tokens = tokens[lparen_idx+1..rparen_idx-1].reject { |r|
-          formatting_tokens.include? r.type
-        }
-
+      unless class_idx[:param_tokens].nil?
         paren_stack = []
-        param_tokens.each_index do |param_tokens_idx|
-          this_token = param_tokens[param_tokens_idx]
-          next_token = param_tokens[param_tokens_idx+1]
-          prev_token = param_tokens[param_tokens_idx-1]
-
-          if this_token.type == :LPAREN
+        class_idx[:param_tokens].each_with_index do |token, i|
+          if token.type == :LPAREN
             paren_stack.push(true)
-          elsif this_token.type == :RPAREN
+          elsif token.type == :RPAREN
             paren_stack.pop
           end
           next unless paren_stack.empty?
 
-          if this_token.type == :VARIABLE
-            if next_token.nil? || next_token.type == :COMMA
-              prev_tokens = param_tokens[0..param_tokens_idx]
+          if token.type == :VARIABLE
+            if token.next_code_token.nil? || [:COMMA, :RPAREN].include?(token.next_code_token.type)
+              prev_tokens = class_idx[:param_tokens][0..i]
               unless prev_tokens.rindex { |r| r.type == :EQUALS }.nil?
-                unless prev_token.nil? or prev_token.type == :EQUALS
+                unless token.prev_code_token.nil? or token.prev_code_token.type == :EQUALS
                   msg = 'optional parameter listed before required parameter'
                   notify :warning, {
-                    :message    => msg,
-                    :linenumber => this_token.line,
-                    :column     => this_token.column,
+                    :message => msg,
+                    :line    => token.line,
+                    :column  => token.column,
                   }
                 end
               end
@@ -204,140 +119,149 @@ class PuppetLint::Plugins::CheckClasses < PuppetLint::CheckPlugin
       end
     end
   end
+end
 
-  # Public: Test the manifest tokens for any classes that inherit across
-  # namespaces and record a warning for each instance found.
-  #
-  # Returns nothing.
-  check 'inherits_across_namespaces' do
+# Public: Test the manifest tokens for any classes that inherit across
+# namespaces and record a warning for each instance found.
+PuppetLint.new_check(:inherits_across_namespaces) do
+  def check
     class_indexes.each do |class_idx|
-      class_token = tokens[class_idx[:start]]
-      class_name_token = class_token.next_code_token
-      inherits_token = class_name_token.next_code_token
-      next if inherits_token.nil?
-
-      if inherits_token.type == :INHERITS
-        inherited_class_token = inherits_token.next_code_token
-        inherited_module_name = inherited_class_token.value.split('::').reject { |r| r.empty? }.first
-        class_module_name = class_name_token.value.split('::').reject { |r| r.empty? }.first
+      unless class_idx[:inherited_token].nil?
+        inherited_module_name = class_idx[:inherited_token].value.split('::').reject { |r| r.empty? }.first
+        class_module_name = class_idx[:name_token].value.split('::').reject { |r| r.empty? }.first
 
         unless class_module_name == inherited_module_name
           notify :warning, {
-            :message    => "class inherits across module namespaces",
-            :linenumber => inherited_class_token.line,
-            :column     => inherited_class_token.column,
+            :message => "class inherits across module namespaces",
+            :line    => class_idx[:inherited_token].line,
+            :column  => class_idx[:inherited_token].column,
           }
         end
       end
     end
   end
+end
+
+# Public: Test the manifest tokens for any classes or defined types that are
+# defined inside another class.
+PuppetLint.new_check(:nested_classes_or_defines) do
+  TOKENS = Set[:CLASS, :DEFINE]
 
-  # Public: Test the manifest tokens for any classes or defined types that are
-  # defined inside another class.
-  #
-  # Returns nothing.
-  check 'nested_classes_or_defines' do
+  def check
     class_indexes.each do |class_idx|
       # Skip the first token so that we don't pick up the first :CLASS
-      class_tokens = tokens[class_idx[:start]+1..class_idx[:end]]
+      class_tokens = class_idx[:tokens][1..-1]
 
       class_tokens.each do |token|
-        if token.type == :CLASS
+        if TOKENS.include?(token.type)
           if token.next_code_token.type != :LBRACE
+            type = token.type == :CLASS ? 'class' : 'defined type'
+
             notify :warning, {
-              :message    => "class defined inside a class",
-              :linenumber => token.line,
-              :column     => token.column,
+              :message => "#{type} defined inside a class",
+              :line    => token.line,
+              :column  => token.column,
             }
           end
         end
-
-        if token.type == :DEFINE
-          notify :warning, {
-            :message    => "define defined inside a class",
-            :linenumber => token.line,
-            :column     => token.column,
-          }
-        end
       end
     end
   end
+end
+
+# Public: Test the manifest tokens for any variables that are referenced in
+# the manifest.  If the variables are not fully qualified or one of the
+# variables automatically created in the scope, check that they have been
+# defined in the local scope and record a warning for each variable that has
+# not.
+PuppetLint.new_check(:variable_scope) do
+  DEFAULT_SCOPE_VARS = Set[
+    'name',
+    'title',
+    'module_name',
+    'environment',
+    'clientcert',
+    'clientversion',
+    'servername',
+    'serverip',
+    'serverversion',
+    'caller_module_name',
+  ]
+  POST_VAR_TOKENS = Set[:COMMA, :EQUALS, :RPAREN]
+
+  def check
+    variables_in_scope = DEFAULT_SCOPE_VARS.clone
 
-  # Public: Test the manifest tokens for any variables that are referenced in
-  # the manifest.  If the variables are not fully qualified or one of the
-  # variables automatically created in the scope, check that they have been
-  # defined in the local scope and record a warning for each variable that has
-  # not.
-  #
-  # Returns nothing.
-  check 'variable_scope' do
-    variables_in_scope = [
-      'name',
-      'title',
-      'module_name',
-      'environment',
-      'clientcert',
-      'clientversion',
-      'servername',
-      'serverip',
-      'serverversion',
-      'caller_module_name',
-    ]
     (class_indexes + defined_type_indexes).each do |idx|
-      object_tokens = tokens[idx[:start]..idx[:end]]
-      object_tokens.reject! { |r| formatting_tokens.include?(r.type) }
-      depth = 0
-      lparen_idx = nil
-      rparen_idx = nil
-      object_tokens.each_index do |t|
-        if object_tokens[t].type == :LPAREN
-          depth += 1
-          lparen_idx = t if depth == 1
-        elsif object_tokens[t].type == :RPAREN
-          depth -= 1
-          if depth == 0
-            rparen_idx = t
-            break
-          end
-        end
-      end
-      referenced_variables = []
+      referenced_variables = Set[]
+      object_tokens = idx[:tokens]
 
-      unless lparen_idx.nil? or rparen_idx.nil?
-        param_tokens = object_tokens[lparen_idx..rparen_idx]
-        param_tokens.each_index do |param_tokens_idx|
-          this_token = param_tokens[param_tokens_idx]
-          next_token = param_tokens[param_tokens_idx+1]
-          if this_token.type == :VARIABLE
-            if {:COMMA => true, :EQUALS => true, :RPAREN => true}.include? next_token.type
-              variables_in_scope << this_token.value
+      unless idx[:param_tokens].nil?
+        idx[:param_tokens].each do |token|
+          if token.type == :VARIABLE
+            if POST_VAR_TOKENS.include? token.next_code_token.type
+              variables_in_scope << token.value
             end
           end
         end
       end
 
-      object_tokens.each_index do |object_token_idx|
-        this_token = object_tokens[object_token_idx]
-        next_token = object_tokens[object_token_idx + 1]
+      future_parser_scopes = {}
+      in_pipe = false
+      temp_scope_vars = []
+
+      object_tokens.each do |token|
+        if token.type == :VARIABLE
+          if in_pipe
+            temp_scope_vars << token.value
+          else
+            if token.next_code_token.type == :EQUALS
+              variables_in_scope << token.value
+            else
+              referenced_variables << token
+            end
+          end
+        elsif token.type == :PIPE
+          in_pipe = !in_pipe
 
-        if this_token.type == :VARIABLE
-          if next_token.type == :EQUALS
-            variables_in_scope << this_token.value
+          if in_pipe
+            temp_scope_vars = []
           else
-            referenced_variables << this_token
+            start_idx = tokens.find_index(token)
+            end_token = nil
+            brace_depth = 0
+
+            tokens[start_idx..-1].each do |sub_token|
+              case sub_token.type
+              when :LBRACE
+                brace_depth += 1
+              when :RBRACE
+                brace_depth -= 1
+                if brace_depth == 0
+                  end_token = sub_token
+                  break
+                end
+              end
+            end
+
+            future_parser_scopes.merge!(Hash[(token.line..end_token.line).to_a.map { |i| [i, temp_scope_vars] }])
           end
         end
       end
 
       msg = "top-scope variable being used without an explicit namespace"
       referenced_variables.each do |token|
+        unless future_parser_scopes[token.line].nil?
+          next if future_parser_scopes[token.line].include?(token.value)
+        end
+
         unless token.value.include? '::'
           unless variables_in_scope.include? token.value
-            unless token.value =~ /\d+/
+            unless token.value =~ /\A\d+\Z/
               notify :warning, {
-                :message    => msg,
-                :linenumber => token.line,
-                :column     => token.column,
+                :message => msg,
+                :line    => token.line,
+                :column  => token.column,
               }
             end
           end